• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1164 (tree)
Time2021-02-23 22:47:07
Authorjakobthomsen

Log Message

allow memory-allocation only in explicitly marked environment

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1163)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1164)
@@ -16073,8 +16073,9 @@
1607316073 // release element id
1607416074 // release element recursive
1607516075 // release element fallible
16076+ // release element canthrow
1607616077 // release variant container
16077- Free(7, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
16078+ Free(8, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
1607816079 label = stack[base - 1];
1607916080 base = stack[base - 2];
1608016081 break;
@@ -16312,10 +16313,29 @@
1631216313 case 1303LLU: // deleter
1631316314 {
1631416315 // throw from mkfndummy
16316+ if(!stack[base + 8])
16317+ {
16318+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16319+ label = 1301LLU; // skip, variable already deleted/unscoped
16320+ break;
16321+ }
16322+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16323+ label = 1301LLU; // continue unrolling stack, delete next variable
16324+ break;
16325+ }
16326+ case 1304LLU: // skipped deleter
16327+ {
16328+ stack[base + 8] = 0;
16329+ label = 1306LLU; // skip deleter
16330+ break;
16331+ }
16332+ case 1305LLU: // deleter
16333+ {
16334+ // throw from mkfndummy
1631516335 if(!stack[base + 0])
1631616336 {
1631716337 fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable fndef \n");
16318- label = 1301LLU; // skip, variable already deleted/unscoped
16338+ label = 1303LLU; // skip, variable already deleted/unscoped
1631916339 break;
1632016340 }
1632116341 fprintf(stderr, "in function mkfndummy: unrolling stack, variable fndef \n");
@@ -16325,7 +16345,7 @@
1632516345 newstack[0] = (uint64_t)stack; // backup stack location
1632616346 newstack[1] = 1234567890;
1632716347 newstack[2] = base;
16328- newstack[3] = 1305LLU;
16348+ newstack[3] = 1307LLU;
1632916349 stack = newstack;
1633016350 // set stack-base & callee-address
1633116351 base = 4/*deloffset*/;
@@ -16332,21 +16352,21 @@
1633216352 label = 1273LLU; // ~fndef
1633316353 break;
1633416354 }
16335- case 1305LLU: // return from ~fndef to mkfndummy
16355+ case 1307LLU: // return from ~fndef to mkfndummy
1633616356 {
1633716357 stack = (uint64_t *)stack[0];
1633816358 // releasing toplevel container
1633916359 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1634016360
16341- label = 1301LLU; // continue unrolling stack, delete next variable
16361+ label = 1303LLU; // continue unrolling stack, delete next variable
1634216362 break;
1634316363 }
16344- case 1304LLU: // skipped deleter
16364+ case 1306LLU: // skipped deleter
1634516365 {
1634616366 // construct fndef.fndef
16347- if(!(stack[base + 0] = construct(7)))
16367+ if(!(stack[base + 0] = construct(8)))
1634816368 {
16349- label = 1301LLU; // throw: begin to unroll stack
16369+ label = 1303LLU; // throw: begin to unroll stack
1635016370 break;
1635116371 }
1635216372
@@ -16359,12 +16379,13 @@
1635916379 (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 5]/*id*/;
1636016380 (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 6]/*recursive*/;
1636116381 (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 7]/*fallible*/;
16382+ (((uint64_t **)(stack[base + 0]))[1][7]) = stack[base + 8]/*canthrow*/;
1636216383 // return from mkfndummy
1636316384 label = stack[base - 1];
1636416385 base = stack[base - 2];
1636516386 break;
1636616387 }
16367- case 1307LLU: // function copyfndef failed
16388+ case 1309LLU: // function copyfndef failed
1636816389 {
1636916390 fprintf(stderr, "function copyfndef failed\n");
1637016391 label = stack[base - 3];
@@ -16371,13 +16392,13 @@
1637116392 base = stack[base - 2];
1637216393 break;
1637316394 }
16374- case 1306LLU: // copyfndef
16395+ case 1308LLU: // copyfndef
1637516396 {
1637616397 //#define res0 0
1637716398 //#define arg0 1
1637816399 if(/*fndef*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
1637916400 {
16380- label = 1309LLU; // jump to alternative
16401+ label = 1311LLU; // jump to alternative
1638116402 break;
1638216403 }
1638316404
@@ -16388,60 +16409,61 @@
1638816409 /*oid*/stack[base + 6] = ((uint64_t **)(stack[base + 1]/*original*/))[1][4]/*id*/;
1638916410 /*orecursive*/stack[base + 7] = ((uint64_t **)(stack[base + 1]/*original*/))[1][5]/*recursive*/;
1639016411 /*ofallible*/stack[base + 8] = ((uint64_t **)(stack[base + 1]/*original*/))[1][6]/*fallible*/;
16412+ /*ocanthrow*/stack[base + 9] = ((uint64_t **)(stack[base + 1]/*original*/))[1][7]/*canthrow*/;
1639116413
1639216414 // case
16393- label = 1311LLU; // skip deleter
16415+ label = 1313LLU; // skip deleter
1639416416 break;
1639516417 }
16396- case 1310LLU: // deleter
16418+ case 1312LLU: // deleter
1639716419 {
1639816420 // throw from copyfndef
16399- if(!stack[base + 9])
16421+ if(!stack[base + 10])
1640016422 {
1640116423 fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16402- label = 1307LLU; // skip, variable already deleted/unscoped
16424+ label = 1309LLU; // skip, variable already deleted/unscoped
1640316425 break;
1640416426 }
1640516427 fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16406- label = 1307LLU; // continue unrolling stack, delete next variable
16428+ label = 1309LLU; // continue unrolling stack, delete next variable
1640716429 break;
1640816430 }
16409- case 1311LLU: // skipped deleter
16431+ case 1313LLU: // skipped deleter
1641016432 {
16411- stack[base + 9] = stack[base + 2]/*olabel*/;
16412- label = 1313LLU; // skip deleter
16433+ stack[base + 10] = stack[base + 2]/*olabel*/;
16434+ label = 1315LLU; // skip deleter
1641316435 break;
1641416436 }
16415- case 1312LLU: // deleter
16437+ case 1314LLU: // deleter
1641616438 {
1641716439 // throw from copyfndef
16418- if(!stack[base + 10])
16440+ if(!stack[base + 11])
1641916441 {
1642016442 fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [result] \n");
16421- label = 1310LLU; // skip, variable already deleted/unscoped
16443+ label = 1312LLU; // skip, variable already deleted/unscoped
1642216444 break;
1642316445 }
1642416446 fprintf(stderr, "in function copyfndef: unrolling stack, variable [result] \n");
1642516447 // delete list
16426- label = 1314LLU; // start to repeat
16448+ label = 1316LLU; // start to repeat
1642716449 break;
1642816450 }
16429- case 1314LLU: // repeat from here
16451+ case 1316LLU: // repeat from here
1643016452 {
16431- if(!stack[base + 10])
16453+ if(!stack[base + 11])
1643216454 {
16433- label = 1315LLU; // break loop
16455+ label = 1317LLU; // break loop
1643416456 break;
1643516457 }
1643616458
1643716459 // delete list loop body
1643816460
16439- uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 10])->data - sizeof(uint64_t) * 4);
16461+ uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4);
1644016462 // call ~result from copyfndef
1644116463 newstack[0] = (uint64_t)stack; // backup stack location
1644216464 newstack[1] = 1234567890;
1644316465 newstack[2] = base;
16444- newstack[3] = 1316LLU;
16466+ newstack[3] = 1318LLU;
1644516467 stack = newstack;
1644616468 // set stack-base & callee-address
1644716469 base = 4/*deloffset*/;
@@ -16448,61 +16470,61 @@
1644816470 label = 382LLU; // ~result
1644916471 break;
1645016472 }
16451- case 1316LLU: // return from ~result to copyfndef
16473+ case 1318LLU: // return from ~result to copyfndef
1645216474 {
1645316475 stack = (uint64_t *)stack[0];
1645416476 // releasing toplevel container
16455- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 10])->data - sizeof(uint64_t) * 4));
16477+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4));
1645616478
1645716479 {
16458- struct listnode *list = (struct listnode *)stack[base + 10];
16459- stack[base + 10] = (uint64_t)list->next;
16480+ struct listnode *list = (struct listnode *)stack[base + 11];
16481+ stack[base + 11] = (uint64_t)list->next;
1646016482 Free(1, sizeof(struct listnode), list);
1646116483 }
16462- label = 1314LLU; // repeat
16484+ label = 1316LLU; // repeat
1646316485 break;
1646416486 }
16465- case 1315LLU: // loop finished
16487+ case 1317LLU: // loop finished
1646616488 {
16467- label = 1310LLU; // continue unrolling stack, delete next variable
16489+ label = 1312LLU; // continue unrolling stack, delete next variable
1646816490 break;
1646916491 }
16470- case 1313LLU: // skipped deleter
16492+ case 1315LLU: // skipped deleter
1647116493 {
16472- stack[base + 10] = 0;
16473- label = 1318LLU; // skip deleter
16494+ stack[base + 11] = 0;
16495+ label = 1320LLU; // skip deleter
1647416496 break;
1647516497 }
16476- case 1317LLU: // deleter
16498+ case 1319LLU: // deleter
1647716499 {
1647816500 // throw from copyfndef
16479- if(!stack[base + 11])
16501+ if(!stack[base + 12])
1648016502 {
1648116503 fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [param] \n");
16482- label = 1312LLU; // skip, variable already deleted/unscoped
16504+ label = 1314LLU; // skip, variable already deleted/unscoped
1648316505 break;
1648416506 }
1648516507 fprintf(stderr, "in function copyfndef: unrolling stack, variable [param] \n");
1648616508 // delete list
16487- label = 1319LLU; // start to repeat
16509+ label = 1321LLU; // start to repeat
1648816510 break;
1648916511 }
16490- case 1319LLU: // repeat from here
16512+ case 1321LLU: // repeat from here
1649116513 {
16492- if(!stack[base + 11])
16514+ if(!stack[base + 12])
1649316515 {
16494- label = 1320LLU; // break loop
16516+ label = 1322LLU; // break loop
1649516517 break;
1649616518 }
1649716519
1649816520 // delete list loop body
1649916521
16500- uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4);
16522+ uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 12])->data - sizeof(uint64_t) * 4);
1650116523 // call ~param from copyfndef
1650216524 newstack[0] = (uint64_t)stack; // backup stack location
1650316525 newstack[1] = 1234567890;
1650416526 newstack[2] = base;
16505- newstack[3] = 1321LLU;
16527+ newstack[3] = 1323LLU;
1650616528 stack = newstack;
1650716529 // set stack-base & callee-address
1650816530 base = 4/*deloffset*/;
@@ -16509,47 +16531,28 @@
1650916531 label = 400LLU; // ~param
1651016532 break;
1651116533 }
16512- case 1321LLU: // return from ~param to copyfndef
16534+ case 1323LLU: // return from ~param to copyfndef
1651316535 {
1651416536 stack = (uint64_t *)stack[0];
1651516537 // releasing toplevel container
16516- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4));
16538+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 12])->data - sizeof(uint64_t) * 4));
1651716539
1651816540 {
16519- struct listnode *list = (struct listnode *)stack[base + 11];
16520- stack[base + 11] = (uint64_t)list->next;
16541+ struct listnode *list = (struct listnode *)stack[base + 12];
16542+ stack[base + 12] = (uint64_t)list->next;
1652116543 Free(1, sizeof(struct listnode), list);
1652216544 }
16523- label = 1319LLU; // repeat
16545+ label = 1321LLU; // repeat
1652416546 break;
1652516547 }
16526- case 1320LLU: // loop finished
16548+ case 1322LLU: // loop finished
1652716549 {
16528- label = 1312LLU; // continue unrolling stack, delete next variable
16550+ label = 1314LLU; // continue unrolling stack, delete next variable
1652916551 break;
1653016552 }
16531- case 1318LLU: // skipped deleter
16553+ case 1320LLU: // skipped deleter
1653216554 {
16533- stack[base + 11] = 0;
16534- label = 1323LLU; // skip deleter
16535- break;
16536- }
16537- case 1322LLU: // deleter
16538- {
16539- // throw from copyfndef
16540- if(!stack[base + 12])
16541- {
16542- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16543- label = 1317LLU; // skip, variable already deleted/unscoped
16544- break;
16545- }
16546- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16547- label = 1317LLU; // continue unrolling stack, delete next variable
16548- break;
16549- }
16550- case 1323LLU: // skipped deleter
16551- {
16552- stack[base + 12] = stack[base + 5]/*omaxcount*/;
16555+ stack[base + 12] = 0;
1655316556 label = 1325LLU; // skip deleter
1655416557 break;
1655516558 }
@@ -16559,16 +16562,16 @@
1655916562 if(!stack[base + 13])
1656016563 {
1656116564 fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16562- label = 1322LLU; // skip, variable already deleted/unscoped
16565+ label = 1319LLU; // skip, variable already deleted/unscoped
1656316566 break;
1656416567 }
1656516568 fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16566- label = 1322LLU; // continue unrolling stack, delete next variable
16569+ label = 1319LLU; // continue unrolling stack, delete next variable
1656716570 break;
1656816571 }
1656916572 case 1325LLU: // skipped deleter
1657016573 {
16571- stack[base + 13] = stack[base + 6]/*oid*/;
16574+ stack[base + 13] = stack[base + 5]/*omaxcount*/;
1657216575 label = 1327LLU; // skip deleter
1657316576 break;
1657416577 }
@@ -16587,7 +16590,7 @@
1658716590 }
1658816591 case 1327LLU: // skipped deleter
1658916592 {
16590- stack[base + 14] = stack[base + 7]/*orecursive*/;
16593+ stack[base + 14] = stack[base + 6]/*oid*/;
1659116594 label = 1329LLU; // skip deleter
1659216595 break;
1659316596 }
@@ -16606,46 +16609,84 @@
1660616609 }
1660716610 case 1329LLU: // skipped deleter
1660816611 {
16609- stack[base + 15] = stack[base + 8]/*ofallible*/;
16610- flippedassign(stack[base + 3]/*orestypes*/, &stack[base + 16]);
16611- label = 1330LLU; // start to repeat
16612+ stack[base + 15] = stack[base + 7]/*orecursive*/;
16613+ label = 1331LLU; // skip deleter
1661216614 break;
1661316615 }
16614- case 1330LLU: // repeat from here
16616+ case 1330LLU: // deleter
1661516617 {
16618+ // throw from copyfndef
1661616619 if(!stack[base + 16])
1661716620 {
16618- label = 1331LLU; // break loop
16621+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16622+ label = 1328LLU; // skip, variable already deleted/unscoped
1661916623 break;
1662016624 }
16625+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16626+ label = 1328LLU; // continue unrolling stack, delete next variable
16627+ break;
16628+ }
16629+ case 1331LLU: // skipped deleter
16630+ {
16631+ stack[base + 16] = stack[base + 8]/*ofallible*/;
16632+ label = 1333LLU; // skip deleter
16633+ break;
16634+ }
16635+ case 1332LLU: // deleter
16636+ {
16637+ // throw from copyfndef
16638+ if(!stack[base + 17])
16639+ {
16640+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16641+ label = 1330LLU; // skip, variable already deleted/unscoped
16642+ break;
16643+ }
16644+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16645+ label = 1330LLU; // continue unrolling stack, delete next variable
16646+ break;
16647+ }
16648+ case 1333LLU: // skipped deleter
16649+ {
16650+ stack[base + 17] = stack[base + 9]/*ocanthrow*/;
16651+ flippedassign(stack[base + 3]/*orestypes*/, &stack[base + 18]);
16652+ label = 1334LLU; // start to repeat
16653+ break;
16654+ }
16655+ case 1334LLU: // repeat from here
16656+ {
16657+ if(!stack[base + 18])
16658+ {
16659+ label = 1335LLU; // break loop
16660+ break;
16661+ }
1662116662
1662216663 // loop body
16623- stack[base + 17] = (uint64_t)(((const struct listnode *)(stack[base + 16]))->data);
16624- stack[base + 18]/*previous*/ = stack[base + 16];
16625- stack[base + 16] = (uint64_t)(((const struct listnode *)(stack[base + 16]))->next);
16664+ stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->data);
16665+ stack[base + 20]/*previous*/ = stack[base + 18];
16666+ stack[base + 18] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->next);
1662616667 // call copyresult from copyfndef
16627- stack[base + 20LLU] = 1332LLU/*throw to this address*/;
16628- stack[base + 21LLU] = base;
16629- stack[base + 22LLU] = 1333LLU;
16668+ stack[base + 22LLU] = 1336LLU/*throw to this address*/;
16669+ stack[base + 23LLU] = base;
16670+ stack[base + 24LLU] = 1337LLU;
1663016671 // arguments for call to copyresult
16631- stack[base + 24LLU] = stack[base + 17]/*origresult*/;
16672+ stack[base + 26LLU] = stack[base + 19]/*origresult*/;
1663216673 // set stack-base & callee-address
16633- base += 23LLU;
16674+ base += 25LLU;
1663416675 label = 385LLU; // copyresult
1663516676 break;
1663616677 }
16637- case 1332LLU: // copy-back deleter (copyresult to copyfndef)
16678+ case 1336LLU: // copy-back deleter (copyresult to copyfndef)
1663816679 {
1663916680 fprintf(stderr, "in function copyfndef: unrolling stack, copy-back (copyresult to copyfndef)\n");
1664016681 // copy mutable arguments back from call to copyresult
16641- label = 1328LLU; // continue to roll stack
16682+ label = 1332LLU; // continue to roll stack
1664216683 break;
1664316684 }
16644- case 1333LLU: // return from copyresult to copyfndef
16685+ case 1337LLU: // return from copyresult to copyfndef
1664516686 {
1664616687 // copy mutable arguments back from call to copyresult
1664716688 // copy back results provided by call to copyresult
16648- stack[base + 19] = stack[base + 23LLU];
16689+ stack[base + 21] = stack[base + 25LLU];
1664916690 {
1665016691 struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
1665116692 if(!list)
@@ -16653,56 +16694,56 @@
1665316694 fprintf(stderr, "in function copyfndef push to [result]: OUT OF MEMORY!");
1665416695 exit(-1);
1665516696 }
16656- list->next = (struct listnode *)stack[base + 10]/*crestypes*/;
16657- stack[base + 10]/*crestypes*/ = (uint64_t)list;
16658- MOVE(&list->data, &stack[base + 19]/*copyresult*/);
16697+ list->next = (struct listnode *)stack[base + 11]/*crestypes*/;
16698+ stack[base + 11]/*crestypes*/ = (uint64_t)list;
16699+ MOVE(&list->data, &stack[base + 21]/*copyresult*/);
1665916700 }
16660- ((struct listnode *)(stack[base + 18]/*previous*/))->data = stack[base + 17];
16661- label = 1330LLU; // repeat
16701+ ((struct listnode *)(stack[base + 20]/*previous*/))->data = stack[base + 19];
16702+ label = 1334LLU; // repeat
1666216703 break;
1666316704 }
16664- case 1331LLU: // loop finished
16705+ case 1335LLU: // loop finished
1666516706 {
16666- list_reverse(((struct listnode **)(&stack[base + 10]/*crestypes*/)));
16667- flippedassign(stack[base + 4]/*oargtypes*/, &stack[base + 19]);
16668- label = 1334LLU; // start to repeat
16707+ list_reverse(((struct listnode **)(&stack[base + 11]/*crestypes*/)));
16708+ flippedassign(stack[base + 4]/*oargtypes*/, &stack[base + 21]);
16709+ label = 1338LLU; // start to repeat
1666916710 break;
1667016711 }
16671- case 1334LLU: // repeat from here
16712+ case 1338LLU: // repeat from here
1667216713 {
16673- if(!stack[base + 19])
16714+ if(!stack[base + 21])
1667416715 {
16675- label = 1335LLU; // break loop
16716+ label = 1339LLU; // break loop
1667616717 break;
1667716718 }
1667816719
1667916720 // loop body
16680- stack[base + 20] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->data);
16681- stack[base + 21]/*previous*/ = stack[base + 19];
16682- stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->next);
16721+ stack[base + 22] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->data);
16722+ stack[base + 23]/*previous*/ = stack[base + 21];
16723+ stack[base + 21] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->next);
1668316724 // call copyparam from copyfndef
16684- stack[base + 23LLU] = 1336LLU/*throw to this address*/;
16685- stack[base + 24LLU] = base;
16686- stack[base + 25LLU] = 1337LLU;
16725+ stack[base + 25LLU] = 1340LLU/*throw to this address*/;
16726+ stack[base + 26LLU] = base;
16727+ stack[base + 27LLU] = 1341LLU;
1668716728 // arguments for call to copyparam
16688- stack[base + 27LLU] = stack[base + 20]/*origparam*/;
16729+ stack[base + 29LLU] = stack[base + 22]/*origparam*/;
1668916730 // set stack-base & callee-address
16690- base += 26LLU;
16731+ base += 28LLU;
1669116732 label = 403LLU; // copyparam
1669216733 break;
1669316734 }
16694- case 1336LLU: // copy-back deleter (copyparam to copyfndef)
16735+ case 1340LLU: // copy-back deleter (copyparam to copyfndef)
1669516736 {
1669616737 fprintf(stderr, "in function copyfndef: unrolling stack, copy-back (copyparam to copyfndef)\n");
1669716738 // copy mutable arguments back from call to copyparam
16698- label = 1328LLU; // continue to roll stack
16739+ label = 1332LLU; // continue to roll stack
1669916740 break;
1670016741 }
16701- case 1337LLU: // return from copyparam to copyfndef
16742+ case 1341LLU: // return from copyparam to copyfndef
1670216743 {
1670316744 // copy mutable arguments back from call to copyparam
1670416745 // copy back results provided by call to copyparam
16705- stack[base + 22] = stack[base + 26LLU];
16746+ stack[base + 24] = stack[base + 28LLU];
1670616747 {
1670716748 struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
1670816749 if(!list)
@@ -16710,27 +16751,27 @@
1671016751 fprintf(stderr, "in function copyfndef push to [param]: OUT OF MEMORY!");
1671116752 exit(-1);
1671216753 }
16713- list->next = (struct listnode *)stack[base + 11]/*cargtypes*/;
16714- stack[base + 11]/*cargtypes*/ = (uint64_t)list;
16715- MOVE(&list->data, &stack[base + 22]/*copyparam*/);
16754+ list->next = (struct listnode *)stack[base + 12]/*cargtypes*/;
16755+ stack[base + 12]/*cargtypes*/ = (uint64_t)list;
16756+ MOVE(&list->data, &stack[base + 24]/*copyparam*/);
1671616757 }
16717- ((struct listnode *)(stack[base + 21]/*previous*/))->data = stack[base + 20];
16718- label = 1334LLU; // repeat
16758+ ((struct listnode *)(stack[base + 23]/*previous*/))->data = stack[base + 22];
16759+ label = 1338LLU; // repeat
1671916760 break;
1672016761 }
16721- case 1335LLU: // loop finished
16762+ case 1339LLU: // loop finished
1672216763 {
16723- list_reverse(((struct listnode **)(&stack[base + 11]/*cargtypes*/)));
16724- label = 1339LLU; // skip deleter
16764+ list_reverse(((struct listnode **)(&stack[base + 12]/*cargtypes*/)));
16765+ label = 1343LLU; // skip deleter
1672516766 break;
1672616767 }
16727- case 1338LLU: // deleter
16768+ case 1342LLU: // deleter
1672816769 {
1672916770 // throw from copyfndef
1673016771 if(!stack[base + 0])
1673116772 {
1673216773 fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable fndef \n");
16733- label = 1328LLU; // skip, variable already deleted/unscoped
16774+ label = 1332LLU; // skip, variable already deleted/unscoped
1673416775 break;
1673516776 }
1673616777 fprintf(stderr, "in function copyfndef: unrolling stack, variable fndef \n");
@@ -16740,7 +16781,7 @@
1674016781 newstack[0] = (uint64_t)stack; // backup stack location
1674116782 newstack[1] = 1234567890;
1674216783 newstack[2] = base;
16743- newstack[3] = 1340LLU;
16784+ newstack[3] = 1344LLU;
1674416785 stack = newstack;
1674516786 // set stack-base & callee-address
1674616787 base = 4/*deloffset*/;
@@ -16747,33 +16788,35 @@
1674716788 label = 1273LLU; // ~fndef
1674816789 break;
1674916790 }
16750- case 1340LLU: // return from ~fndef to copyfndef
16791+ case 1344LLU: // return from ~fndef to copyfndef
1675116792 {
1675216793 stack = (uint64_t *)stack[0];
1675316794 // releasing toplevel container
1675416795 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1675516796
16756- label = 1328LLU; // continue unrolling stack, delete next variable
16797+ label = 1332LLU; // continue unrolling stack, delete next variable
1675716798 break;
1675816799 }
16759- case 1339LLU: // skipped deleter
16800+ case 1343LLU: // skipped deleter
1676016801 {
1676116802 // construct fndef.fndef
16762- if(!(stack[base + 0] = construct(7)))
16803+ if(!(stack[base + 0] = construct(8)))
1676316804 {
16764- label = 1328LLU; // throw: begin to unroll stack
16805+ label = 1332LLU; // throw: begin to unroll stack
1676516806 break;
1676616807 }
1676716808
1676816809 // consequent
1676916810 ((uint64_t *)stack[base + 0])[0] = 0;
16770- (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 9]/*clabel*/;
16771- INIT(&(((uint64_t **)(stack[base + 0]))[1][1]), &stack[base + 10]/*crestypes*/);
16772- INIT(&(((uint64_t **)(stack[base + 0]))[1][2]), &stack[base + 11]/*cargtypes*/);
16773- (((uint64_t **)(stack[base + 0]))[1][3]) = stack[base + 12]/*cmaxcount*/;
16774- (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 13]/*cid*/;
16775- (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 14]/*crecursive*/;
16776- (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 15]/*cfallible*/;
16811+ (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 10]/*clabel*/;
16812+ INIT(&(((uint64_t **)(stack[base + 0]))[1][1]), &stack[base + 11]/*crestypes*/);
16813+ INIT(&(((uint64_t **)(stack[base + 0]))[1][2]), &stack[base + 12]/*cargtypes*/);
16814+ (((uint64_t **)(stack[base + 0]))[1][3]) = stack[base + 13]/*cmaxcount*/;
16815+ (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 14]/*cid*/;
16816+ (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 15]/*crecursive*/;
16817+ (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 16]/*cfallible*/;
16818+ (((uint64_t **)(stack[base + 0]))[1][7]) = stack[base + 17]/*ccanthrow*/;
16819+ ((uint64_t **)(stack[base + 1]))[1][7] = stack[base + 9];
1677716820 ((uint64_t **)(stack[base + 1]))[1][6] = stack[base + 8];
1677816821 ((uint64_t **)(stack[base + 1]))[1][5] = stack[base + 7];
1677916822 ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
@@ -16781,15 +16824,15 @@
1678116824 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
1678216825 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
1678316826 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
16784- label = 1308LLU; // case complete
16827+ label = 1310LLU; // case complete
1678516828 break;
1678616829 }
16787- case 1309LLU: // try next case
16830+ case 1311LLU: // try next case
1678816831 {
1678916832 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1679016833 exit(-1);
1679116834 }
16792- case 1308LLU: // completed switch
16835+ case 1310LLU: // completed switch
1679316836 {
1679416837 // return from copyfndef
1679516838 label = stack[base - 1];
@@ -16796,7 +16839,7 @@
1679616839 base = stack[base - 2];
1679716840 break;
1679816841 }
16799- case 1342LLU: // function FindFn failed
16842+ case 1346LLU: // function FindFn failed
1680016843 {
1680116844 fprintf(stderr, "function FindFn failed\n");
1680216845 label = stack[base - 3];
@@ -16803,7 +16846,7 @@
1680316846 base = stack[base - 2];
1680416847 break;
1680516848 }
16806- case 1341LLU: // FindFn
16849+ case 1345LLU: // FindFn
1680716850 {
1680816851 //#define res0 0
1680916852 //#define arg0 1
@@ -16810,9 +16853,9 @@
1681016853 //#define arg1 2
1681116854 //#define arg2 3
1681216855 // call mkfndummy from FindFn
16813- stack[base + 5LLU] = 1343LLU/*throw to this address*/;
16856+ stack[base + 5LLU] = 1347LLU/*throw to this address*/;
1681416857 stack[base + 6LLU] = base;
16815- stack[base + 7LLU] = 1344LLU;
16858+ stack[base + 7LLU] = 1348LLU;
1681616859 // arguments for call to mkfndummy
1681716860 // set stack-base & callee-address
1681816861 base += 8LLU;
@@ -16819,46 +16862,46 @@
1681916862 label = 1281LLU; // mkfndummy
1682016863 break;
1682116864 }
16822- case 1343LLU: // copy-back deleter (mkfndummy to FindFn)
16865+ case 1347LLU: // copy-back deleter (mkfndummy to FindFn)
1682316866 {
1682416867 fprintf(stderr, "in function FindFn: unrolling stack, copy-back (mkfndummy to FindFn)\n");
1682516868 // copy mutable arguments back from call to mkfndummy
16826- label = 1342LLU; // continue to roll stack
16869+ label = 1346LLU; // continue to roll stack
1682716870 break;
1682816871 }
16829- case 1344LLU: // return from mkfndummy to FindFn
16872+ case 1348LLU: // return from mkfndummy to FindFn
1683016873 {
1683116874 // copy mutable arguments back from call to mkfndummy
1683216875 // copy back results provided by call to mkfndummy
1683316876 stack[base + 4] = stack[base + 8LLU];
16834- label = 1346LLU; // skip deleter
16877+ label = 1350LLU; // skip deleter
1683516878 break;
1683616879 }
16837- case 1345LLU: // deleter
16880+ case 1349LLU: // deleter
1683816881 {
1683916882 // throw from FindFn
1684016883 if(!stack[base + 5])
1684116884 {
1684216885 fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16843- label = 1342LLU; // skip, variable already deleted/unscoped
16886+ label = 1346LLU; // skip, variable already deleted/unscoped
1684416887 break;
1684516888 }
1684616889 fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n");
16847- label = 1342LLU; // continue unrolling stack, delete next variable
16890+ label = 1346LLU; // continue unrolling stack, delete next variable
1684816891 break;
1684916892 }
16850- case 1346LLU: // skipped deleter
16893+ case 1350LLU: // skipped deleter
1685116894 {
1685216895 stack[base + 5] = 0;
1685316896 flippedassign(stack[base + 2]/*fndefs*/, &stack[base + 6]);
16854- label = 1347LLU; // start to repeat
16897+ label = 1351LLU; // start to repeat
1685516898 break;
1685616899 }
16857- case 1347LLU: // repeat from here
16900+ case 1351LLU: // repeat from here
1685816901 {
1685916902 if(!stack[base + 6])
1686016903 {
16861- label = 1348LLU; // break loop
16904+ label = 1352LLU; // break loop
1686216905 break;
1686316906 }
1686416907
@@ -16868,19 +16911,19 @@
1686816911 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
1686916912 if(!stack[base + 5]/*found*/)
1687016913 {
16871- label = 1349LLU; // jump to alternative
16914+ label = 1353LLU; // jump to alternative
1687216915 break;
1687316916 }
1687416917
1687516918 // consequent
16876- label = 1350LLU; // consequent complete
16919+ label = 1354LLU; // consequent complete
1687716920 break;
1687816921 }
16879- case 1349LLU: // alternative
16922+ case 1353LLU: // alternative
1688016923 {
1688116924 if(/*fndef*/0 != ((uint64_t *)(stack[base + 7]/*fndef*/))[0])
1688216925 {
16883- label = 1352LLU; // jump to alternative
16926+ label = 1356LLU; // jump to alternative
1688416927 break;
1688516928 }
1688616929
@@ -16891,90 +16934,91 @@
1689116934 /*defid*/stack[base + 13] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][4]/*id*/;
1689216935 /*recursive*/stack[base + 14] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][5]/*recursive*/;
1689316936 /*fallible*/stack[base + 15] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][6]/*fallible*/;
16937+ /*canthrow*/stack[base + 16] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][7]/*canthrow*/;
1689416938
1689516939 // case
16896- label = 1354LLU; // skip deleter
16940+ label = 1358LLU; // skip deleter
1689716941 break;
1689816942 }
16899- case 1353LLU: // deleter
16943+ case 1357LLU: // deleter
1690016944 {
1690116945 // throw from FindFn
16902- if(!stack[base + 16])
16946+ if(!stack[base + 17])
1690316947 {
1690416948 fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16905- label = 1345LLU; // skip, variable already deleted/unscoped
16949+ label = 1349LLU; // skip, variable already deleted/unscoped
1690616950 break;
1690716951 }
1690816952 fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n");
16909- label = 1345LLU; // continue unrolling stack, delete next variable
16953+ label = 1349LLU; // continue unrolling stack, delete next variable
1691016954 break;
1691116955 }
16912- case 1354LLU: // skipped deleter
16956+ case 1358LLU: // skipped deleter
1691316957 {
16914- stack[base + 16] = 0;
16958+ stack[base + 17] = 0;
1691516959 // call equ from FindFn
16916- stack[base + 17LLU] = 1355LLU/*throw to this address*/;
16917- stack[base + 18LLU] = base;
16918- stack[base + 19LLU] = 1356LLU;
16960+ stack[base + 18LLU] = 1359LLU/*throw to this address*/;
16961+ stack[base + 19LLU] = base;
16962+ stack[base + 20LLU] = 1360LLU;
1691916963 // arguments for call to equ
16920- stack[base + 21LLU] = stack[base + 3]/*id*/;
16921- stack[base + 22LLU] = stack[base + 13]/*defid*/;
16964+ stack[base + 22LLU] = stack[base + 3]/*id*/;
16965+ stack[base + 23LLU] = stack[base + 13]/*defid*/;
1692216966 // set stack-base & callee-address
16923- base += 20LLU;
16967+ base += 21LLU;
1692416968 label = 18446744073709551600LLU; // equ
1692516969 break;
1692616970 }
16927- case 1355LLU: // copy-back deleter (equ to FindFn)
16971+ case 1359LLU: // copy-back deleter (equ to FindFn)
1692816972 {
1692916973 fprintf(stderr, "in function FindFn: unrolling stack, copy-back (equ to FindFn)\n");
1693016974 // copy mutable arguments back from call to equ
16931- label = 1353LLU; // continue to roll stack
16975+ label = 1357LLU; // continue to roll stack
1693216976 break;
1693316977 }
16934- case 1356LLU: // return from equ to FindFn
16978+ case 1360LLU: // return from equ to FindFn
1693516979 {
1693616980 // copy mutable arguments back from call to equ
1693716981 // copy back results provided by call to equ
16938- stack[base + 16] = stack[base + 20LLU];
16939- if(!stack[base + 16]/*isequal*/)
16982+ stack[base + 17] = stack[base + 21LLU];
16983+ if(!stack[base + 17]/*isequal*/)
1694016984 {
16941- label = 1357LLU; // jump to alternative
16985+ label = 1361LLU; // jump to alternative
1694216986 break;
1694316987 }
1694416988
1694516989 // consequent
1694616990 // call copyfndef from FindFn
16947- stack[base + 18LLU] = 1359LLU/*throw to this address*/;
16948- stack[base + 19LLU] = base;
16949- stack[base + 20LLU] = 1360LLU;
16991+ stack[base + 19LLU] = 1363LLU/*throw to this address*/;
16992+ stack[base + 20LLU] = base;
16993+ stack[base + 21LLU] = 1364LLU;
1695016994 // arguments for call to copyfndef
16951- stack[base + 22LLU] = stack[base + 7]/*fndef*/;
16995+ stack[base + 23LLU] = stack[base + 7]/*fndef*/;
1695216996 // set stack-base & callee-address
16953- base += 21LLU;
16954- label = 1306LLU; // copyfndef
16997+ base += 22LLU;
16998+ label = 1308LLU; // copyfndef
1695516999 break;
1695617000 }
16957- case 1359LLU: // copy-back deleter (copyfndef to FindFn)
17001+ case 1363LLU: // copy-back deleter (copyfndef to FindFn)
1695817002 {
1695917003 fprintf(stderr, "in function FindFn: unrolling stack, copy-back (copyfndef to FindFn)\n");
1696017004 // copy mutable arguments back from call to copyfndef
16961- label = 1353LLU; // continue to roll stack
17005+ label = 1357LLU; // continue to roll stack
1696217006 break;
1696317007 }
16964- case 1360LLU: // return from copyfndef to FindFn
17008+ case 1364LLU: // return from copyfndef to FindFn
1696517009 {
1696617010 // copy mutable arguments back from call to copyfndef
1696717011 // copy back results provided by call to copyfndef
16968- stack[base + 17] = stack[base + 21LLU];
16969- swap(&stack[base + 4], &stack[base + 17]);
17012+ stack[base + 18] = stack[base + 22LLU];
17013+ swap(&stack[base + 4], &stack[base + 18]);
1697017014 stack[base + 5]/*found*/ = 1;
1697117015
16972- uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
17016+ uint64_t *newstack = (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4);
1697317017 // call ~fndef from FindFn
1697417018 newstack[0] = (uint64_t)stack; // backup stack location
1697517019 newstack[1] = 1234567890;
1697617020 newstack[2] = base;
16977- newstack[3] = 1361LLU;
17021+ newstack[3] = 1365LLU;
1697817022 stack = newstack;
1697917023 // set stack-base & callee-address
1698017024 base = 4/*deloffset*/;
@@ -16981,22 +17025,23 @@
1698117025 label = 1273LLU; // ~fndef
1698217026 break;
1698317027 }
16984- case 1361LLU: // return from ~fndef to FindFn
17028+ case 1365LLU: // return from ~fndef to FindFn
1698517029 {
1698617030 stack = (uint64_t *)stack[0];
1698717031 // releasing toplevel container
16988- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
17032+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1698917033
16990- label = 1358LLU; // consequent complete
17034+ label = 1362LLU; // consequent complete
1699117035 break;
1699217036 }
16993- case 1357LLU: // alternative
17037+ case 1361LLU: // alternative
1699417038 {
16995- label = 1358LLU; // alternative complete
17039+ label = 1362LLU; // alternative complete
1699617040 break;
1699717041 }
16998- case 1358LLU: // completed if-then-else
17042+ case 1362LLU: // completed if-then-else
1699917043 {
17044+ ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1700017045 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
1700117046 ((uint64_t **)(stack[base + 7]))[1][5] = stack[base + 14];
1700217047 ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 13];
@@ -17004,44 +17049,44 @@
1700417049 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1700517050 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1700617051 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
17007- label = 1351LLU; // case complete
17052+ label = 1355LLU; // case complete
1700817053 break;
1700917054 }
17010- case 1352LLU: // try next case
17055+ case 1356LLU: // try next case
1701117056 {
1701217057 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1701317058 exit(-1);
1701417059 }
17015- case 1351LLU: // completed switch
17060+ case 1355LLU: // completed switch
1701617061 {
17017- label = 1350LLU; // alternative complete
17062+ label = 1354LLU; // alternative complete
1701817063 break;
1701917064 }
17020- case 1350LLU: // completed if-then-else
17065+ case 1354LLU: // completed if-then-else
1702117066 {
1702217067 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
17023- label = 1347LLU; // repeat
17068+ label = 1351LLU; // repeat
1702417069 break;
1702517070 }
17026- case 1348LLU: // loop finished
17071+ case 1352LLU: // loop finished
1702717072 {
1702817073 if(!stack[base + 5]/*found*/)
1702917074 {
17030- label = 1362LLU; // jump to alternative
17075+ label = 1366LLU; // jump to alternative
1703117076 break;
1703217077 }
1703317078
1703417079 // consequent
17035- label = 1363LLU; // consequent complete
17080+ label = 1367LLU; // consequent complete
1703617081 break;
1703717082 }
17038- case 1362LLU: // alternative
17083+ case 1366LLU: // alternative
1703917084 {
1704017085 fprintf(stderr, "%s", "in function ");
1704117086 // call reportid from FindFn
17042- stack[base + 9LLU] = 1364LLU/*throw to this address*/;
17087+ stack[base + 9LLU] = 1368LLU/*throw to this address*/;
1704317088 stack[base + 10LLU] = base;
17044- stack[base + 11LLU] = 1365LLU;
17089+ stack[base + 11LLU] = 1369LLU;
1704517090 // arguments for call to reportid
1704617091 stack[base + 12LLU] = stack[base + 1]/*fnid*/;
1704717092 // set stack-base & callee-address
@@ -17049,22 +17094,22 @@
1704917094 label = 18446744073709551586LLU; // reportid
1705017095 break;
1705117096 }
17052- case 1364LLU: // copy-back deleter (reportid to FindFn)
17097+ case 1368LLU: // copy-back deleter (reportid to FindFn)
1705317098 {
1705417099 fprintf(stderr, "in function FindFn: unrolling stack, copy-back (reportid to FindFn)\n");
1705517100 // copy mutable arguments back from call to reportid
17056- label = 1345LLU; // continue to roll stack
17101+ label = 1349LLU; // continue to roll stack
1705717102 break;
1705817103 }
17059- case 1365LLU: // return from reportid to FindFn
17104+ case 1369LLU: // return from reportid to FindFn
1706017105 {
1706117106 // copy mutable arguments back from call to reportid
1706217107 fprintf(stderr, "%s", ": ");
1706317108 fprintf(stderr, "%s", "function ");
1706417109 // call reportid from FindFn
17065- stack[base + 9LLU] = 1366LLU/*throw to this address*/;
17110+ stack[base + 9LLU] = 1370LLU/*throw to this address*/;
1706617111 stack[base + 10LLU] = base;
17067- stack[base + 11LLU] = 1367LLU;
17112+ stack[base + 11LLU] = 1371LLU;
1706817113 // arguments for call to reportid
1706917114 stack[base + 12LLU] = stack[base + 3]/*id*/;
1707017115 // set stack-base & callee-address
@@ -17072,33 +17117,33 @@
1707217117 label = 18446744073709551586LLU; // reportid
1707317118 break;
1707417119 }
17075- case 1366LLU: // copy-back deleter (reportid to FindFn)
17120+ case 1370LLU: // copy-back deleter (reportid to FindFn)
1707617121 {
1707717122 fprintf(stderr, "in function FindFn: unrolling stack, copy-back (reportid to FindFn)\n");
1707817123 // copy mutable arguments back from call to reportid
17079- label = 1345LLU; // continue to roll stack
17124+ label = 1349LLU; // continue to roll stack
1708017125 break;
1708117126 }
17082- case 1367LLU: // return from reportid to FindFn
17127+ case 1371LLU: // return from reportid to FindFn
1708317128 {
1708417129 // copy mutable arguments back from call to reportid
1708517130 fprintf(stderr, "%s", " not defined\n");
1708617131 exit(-1);
17087- label = 1363LLU; // alternative complete
17132+ label = 1367LLU; // alternative complete
1708817133 break;
1708917134 }
17090- case 1363LLU: // completed if-then-else
17135+ case 1367LLU: // completed if-then-else
1709117136 {
17092- label = 1369LLU; // skip deleter
17137+ label = 1373LLU; // skip deleter
1709317138 break;
1709417139 }
17095- case 1368LLU: // deleter
17140+ case 1372LLU: // deleter
1709617141 {
1709717142 // throw from FindFn
1709817143 if(!stack[base + 0])
1709917144 {
1710017145 fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable fndef \n");
17101- label = 1345LLU; // skip, variable already deleted/unscoped
17146+ label = 1349LLU; // skip, variable already deleted/unscoped
1710217147 break;
1710317148 }
1710417149 fprintf(stderr, "in function FindFn: unrolling stack, variable fndef \n");
@@ -17108,7 +17153,7 @@
1710817153 newstack[0] = (uint64_t)stack; // backup stack location
1710917154 newstack[1] = 1234567890;
1711017155 newstack[2] = base;
17111- newstack[3] = 1370LLU;
17156+ newstack[3] = 1374LLU;
1711217157 stack = newstack;
1711317158 // set stack-base & callee-address
1711417159 base = 4/*deloffset*/;
@@ -17115,16 +17160,16 @@
1711517160 label = 1273LLU; // ~fndef
1711617161 break;
1711717162 }
17118- case 1370LLU: // return from ~fndef to FindFn
17163+ case 1374LLU: // return from ~fndef to FindFn
1711917164 {
1712017165 stack = (uint64_t *)stack[0];
1712117166 // releasing toplevel container
1712217167 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1712317168
17124- label = 1345LLU; // continue unrolling stack, delete next variable
17169+ label = 1349LLU; // continue unrolling stack, delete next variable
1712517170 break;
1712617171 }
17127- case 1369LLU: // skipped deleter
17172+ case 1373LLU: // skipped deleter
1712817173 {
1712917174 INIT(&stack[base + 0], &stack[base + 4]/*copy*/);
1713017175 // return from FindFn
@@ -17132,7 +17177,7 @@
1713217177 base = stack[base - 2];
1713317178 break;
1713417179 }
17135- case 1372LLU: // function existsfn failed
17180+ case 1376LLU: // function existsfn failed
1713617181 {
1713717182 fprintf(stderr, "function existsfn failed\n");
1713817183 label = stack[base - 3];
@@ -17139,39 +17184,39 @@
1713917184 base = stack[base - 2];
1714017185 break;
1714117186 }
17142- case 1371LLU: // existsfn
17187+ case 1375LLU: // existsfn
1714317188 {
1714417189 //#define res0 0
1714517190 //#define arg0 1
1714617191 //#define arg1 2
17147- label = 1374LLU; // skip deleter
17192+ label = 1378LLU; // skip deleter
1714817193 break;
1714917194 }
17150- case 1373LLU: // deleter
17195+ case 1377LLU: // deleter
1715117196 {
1715217197 // throw from existsfn
1715317198 if(!stack[base + 3])
1715417199 {
1715517200 fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17156- label = 1372LLU; // skip, variable already deleted/unscoped
17201+ label = 1376LLU; // skip, variable already deleted/unscoped
1715717202 break;
1715817203 }
1715917204 fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n");
17160- label = 1372LLU; // continue unrolling stack, delete next variable
17205+ label = 1376LLU; // continue unrolling stack, delete next variable
1716117206 break;
1716217207 }
17163- case 1374LLU: // skipped deleter
17208+ case 1378LLU: // skipped deleter
1716417209 {
1716517210 stack[base + 3] = 0;
1716617211 flippedassign(stack[base + 1]/*fndefs*/, &stack[base + 4]);
17167- label = 1375LLU; // start to repeat
17212+ label = 1379LLU; // start to repeat
1716817213 break;
1716917214 }
17170- case 1375LLU: // repeat from here
17215+ case 1379LLU: // repeat from here
1717117216 {
1717217217 if(!stack[base + 4])
1717317218 {
17174- label = 1376LLU; // break loop
17219+ label = 1380LLU; // break loop
1717517220 break;
1717617221 }
1717717222
@@ -17181,19 +17226,19 @@
1718117226 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1718217227 if(!stack[base + 3]/*found*/)
1718317228 {
17184- label = 1377LLU; // jump to alternative
17229+ label = 1381LLU; // jump to alternative
1718517230 break;
1718617231 }
1718717232
1718817233 // consequent
17189- label = 1378LLU; // consequent complete
17234+ label = 1382LLU; // consequent complete
1719017235 break;
1719117236 }
17192- case 1377LLU: // alternative
17237+ case 1381LLU: // alternative
1719317238 {
1719417239 if(/*fndef*/0 != ((uint64_t *)(stack[base + 5]/*fndef*/))[0])
1719517240 {
17196- label = 1380LLU; // jump to alternative
17241+ label = 1384LLU; // jump to alternative
1719717242 break;
1719817243 }
1719917244
@@ -17204,69 +17249,71 @@
1720417249 /*defid*/stack[base + 11] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][4]/*id*/;
1720517250 /*recursive*/stack[base + 12] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][5]/*recursive*/;
1720617251 /*fallible*/stack[base + 13] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][6]/*fallible*/;
17252+ /*canthrow*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][7]/*canthrow*/;
1720717253
1720817254 // case
17209- label = 1382LLU; // skip deleter
17255+ label = 1386LLU; // skip deleter
1721017256 break;
1721117257 }
17212- case 1381LLU: // deleter
17258+ case 1385LLU: // deleter
1721317259 {
1721417260 // throw from existsfn
17215- if(!stack[base + 14])
17261+ if(!stack[base + 15])
1721617262 {
1721717263 fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17218- label = 1373LLU; // skip, variable already deleted/unscoped
17264+ label = 1377LLU; // skip, variable already deleted/unscoped
1721917265 break;
1722017266 }
1722117267 fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n");
17222- label = 1373LLU; // continue unrolling stack, delete next variable
17268+ label = 1377LLU; // continue unrolling stack, delete next variable
1722317269 break;
1722417270 }
17225- case 1382LLU: // skipped deleter
17271+ case 1386LLU: // skipped deleter
1722617272 {
17227- stack[base + 14] = 0;
17273+ stack[base + 15] = 0;
1722817274 // call equ from existsfn
17229- stack[base + 15LLU] = 1383LLU/*throw to this address*/;
17230- stack[base + 16LLU] = base;
17231- stack[base + 17LLU] = 1384LLU;
17275+ stack[base + 16LLU] = 1387LLU/*throw to this address*/;
17276+ stack[base + 17LLU] = base;
17277+ stack[base + 18LLU] = 1388LLU;
1723217278 // arguments for call to equ
17233- stack[base + 19LLU] = stack[base + 2]/*id*/;
17234- stack[base + 20LLU] = stack[base + 11]/*defid*/;
17279+ stack[base + 20LLU] = stack[base + 2]/*id*/;
17280+ stack[base + 21LLU] = stack[base + 11]/*defid*/;
1723517281 // set stack-base & callee-address
17236- base += 18LLU;
17282+ base += 19LLU;
1723717283 label = 18446744073709551600LLU; // equ
1723817284 break;
1723917285 }
17240- case 1383LLU: // copy-back deleter (equ to existsfn)
17286+ case 1387LLU: // copy-back deleter (equ to existsfn)
1724117287 {
1724217288 fprintf(stderr, "in function existsfn: unrolling stack, copy-back (equ to existsfn)\n");
1724317289 // copy mutable arguments back from call to equ
17244- label = 1381LLU; // continue to roll stack
17290+ label = 1385LLU; // continue to roll stack
1724517291 break;
1724617292 }
17247- case 1384LLU: // return from equ to existsfn
17293+ case 1388LLU: // return from equ to existsfn
1724817294 {
1724917295 // copy mutable arguments back from call to equ
1725017296 // copy back results provided by call to equ
17251- stack[base + 14] = stack[base + 18LLU];
17252- if(!stack[base + 14]/*isequal*/)
17297+ stack[base + 15] = stack[base + 19LLU];
17298+ if(!stack[base + 15]/*isequal*/)
1725317299 {
17254- label = 1385LLU; // jump to alternative
17300+ label = 1389LLU; // jump to alternative
1725517301 break;
1725617302 }
1725717303
1725817304 // consequent
1725917305 stack[base + 3]/*found*/ = 1;
17260- label = 1386LLU; // consequent complete
17306+ label = 1390LLU; // consequent complete
1726117307 break;
1726217308 }
17263- case 1385LLU: // alternative
17309+ case 1389LLU: // alternative
1726417310 {
17265- label = 1386LLU; // alternative complete
17311+ label = 1390LLU; // alternative complete
1726617312 break;
1726717313 }
17268- case 1386LLU: // completed if-then-else
17314+ case 1390LLU: // completed if-then-else
1726917315 {
17316+ ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1727017317 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
1727117318 ((uint64_t **)(stack[base + 5]))[1][5] = stack[base + 12];
1727217319 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
@@ -17274,44 +17321,44 @@
1727417321 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1727517322 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1727617323 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
17277- label = 1379LLU; // case complete
17324+ label = 1383LLU; // case complete
1727817325 break;
1727917326 }
17280- case 1380LLU: // try next case
17327+ case 1384LLU: // try next case
1728117328 {
1728217329 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1728317330 exit(-1);
1728417331 }
17285- case 1379LLU: // completed switch
17332+ case 1383LLU: // completed switch
1728617333 {
17287- label = 1378LLU; // alternative complete
17334+ label = 1382LLU; // alternative complete
1728817335 break;
1728917336 }
17290- case 1378LLU: // completed if-then-else
17337+ case 1382LLU: // completed if-then-else
1729117338 {
1729217339 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
17293- label = 1375LLU; // repeat
17340+ label = 1379LLU; // repeat
1729417341 break;
1729517342 }
17296- case 1376LLU: // loop finished
17343+ case 1380LLU: // loop finished
1729717344 {
17298- label = 1388LLU; // skip deleter
17345+ label = 1392LLU; // skip deleter
1729917346 break;
1730017347 }
17301- case 1387LLU: // deleter
17348+ case 1391LLU: // deleter
1730217349 {
1730317350 // throw from existsfn
1730417351 if(!stack[base + 0])
1730517352 {
1730617353 fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17307- label = 1373LLU; // skip, variable already deleted/unscoped
17354+ label = 1377LLU; // skip, variable already deleted/unscoped
1730817355 break;
1730917356 }
1731017357 fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n");
17311- label = 1373LLU; // continue unrolling stack, delete next variable
17358+ label = 1377LLU; // continue unrolling stack, delete next variable
1731217359 break;
1731317360 }
17314- case 1388LLU: // skipped deleter
17361+ case 1392LLU: // skipped deleter
1731517362 {
1731617363 stack[base + 0] = stack[base + 3]/*found*/;
1731717364 // return from existsfn
@@ -17319,7 +17366,7 @@
1731917366 base = stack[base - 2];
1732017367 break;
1732117368 }
17322- case 1389LLU: // ~idfndef
17369+ case 1393LLU: // ~idfndef
1732317370 {
1732417371 if(stack[base + 0]/*variant-nr*/ >= 1)
1732517372 {
@@ -17326,10 +17373,10 @@
1732617373 fprintf(stderr, "in ~idfndef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1732717374 exit(-1);
1732817375 }
17329- label = 1389LLU + 1LLU + stack[base + 0]/*variant-nr*/;
17376+ label = 1393LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1733017377 break;
1733117378 }
17332- case 1389LLU + 1LLU + 0LLU: // ~idfndef.idfndef
17379+ case 1393LLU + 1LLU + 0LLU: // ~idfndef.idfndef
1733317380 {
1733417381 // release element id
1733517382 // release element fndef
@@ -17340,7 +17387,7 @@
1734017387 newstack[0] = (uint64_t)stack; // backup stack location
1734117388 newstack[1] = 1234567890;
1734217389 newstack[2] = base;
17343- newstack[3] = 1391LLU;
17390+ newstack[3] = 1395LLU;
1734417391 stack = newstack;
1734517392 // set stack-base & callee-address
1734617393 base = 4/*deloffset*/;
@@ -17347,7 +17394,7 @@
1734717394 label = 1273LLU; // ~fndef
1734817395 break;
1734917396 }
17350- case 1391LLU: // return from ~fndef to idfndef
17397+ case 1395LLU: // return from ~fndef to idfndef
1735117398 {
1735217399 stack = (uint64_t *)stack[0];
1735317400 // releasing toplevel container
@@ -17359,7 +17406,7 @@
1735917406 base = stack[base - 2];
1736017407 break;
1736117408 }
17362- case 1393LLU: // function existsidfn failed
17409+ case 1397LLU: // function existsidfn failed
1736317410 {
1736417411 fprintf(stderr, "function existsidfn failed\n");
1736517412 label = stack[base - 3];
@@ -17366,39 +17413,39 @@
1736617413 base = stack[base - 2];
1736717414 break;
1736817415 }
17369- case 1392LLU: // existsidfn
17416+ case 1396LLU: // existsidfn
1737017417 {
1737117418 //#define res0 0
1737217419 //#define arg0 1
1737317420 //#define arg1 2
17374- label = 1395LLU; // skip deleter
17421+ label = 1399LLU; // skip deleter
1737517422 break;
1737617423 }
17377- case 1394LLU: // deleter
17424+ case 1398LLU: // deleter
1737817425 {
1737917426 // throw from existsidfn
1738017427 if(!stack[base + 3])
1738117428 {
1738217429 fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17383- label = 1393LLU; // skip, variable already deleted/unscoped
17430+ label = 1397LLU; // skip, variable already deleted/unscoped
1738417431 break;
1738517432 }
1738617433 fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n");
17387- label = 1393LLU; // continue unrolling stack, delete next variable
17434+ label = 1397LLU; // continue unrolling stack, delete next variable
1738817435 break;
1738917436 }
17390- case 1395LLU: // skipped deleter
17437+ case 1399LLU: // skipped deleter
1739117438 {
1739217439 stack[base + 3] = 0;
1739317440 flippedassign(stack[base + 1]/*idfndefs*/, &stack[base + 4]);
17394- label = 1396LLU; // start to repeat
17441+ label = 1400LLU; // start to repeat
1739517442 break;
1739617443 }
17397- case 1396LLU: // repeat from here
17444+ case 1400LLU: // repeat from here
1739817445 {
1739917446 if(!stack[base + 4])
1740017447 {
17401- label = 1397LLU; // break loop
17448+ label = 1401LLU; // break loop
1740217449 break;
1740317450 }
1740417451
@@ -17408,19 +17455,19 @@
1740817455 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1740917456 if(!stack[base + 3]/*found*/)
1741017457 {
17411- label = 1398LLU; // jump to alternative
17458+ label = 1402LLU; // jump to alternative
1741217459 break;
1741317460 }
1741417461
1741517462 // consequent
17416- label = 1399LLU; // consequent complete
17463+ label = 1403LLU; // consequent complete
1741717464 break;
1741817465 }
17419- case 1398LLU: // alternative
17466+ case 1402LLU: // alternative
1742017467 {
1742117468 if(/*idfndef*/0 != ((uint64_t *)(stack[base + 5]/*idfndef*/))[0])
1742217469 {
17423- label = 1401LLU; // jump to alternative
17470+ label = 1405LLU; // jump to alternative
1742417471 break;
1742517472 }
1742617473
@@ -17428,29 +17475,29 @@
1742817475 /*fndef*/stack[base + 8] = ((uint64_t **)(stack[base + 5]/*idfndef*/))[1][1]/*fndef*/;
1742917476
1743017477 // case
17431- label = 1403LLU; // skip deleter
17478+ label = 1407LLU; // skip deleter
1743217479 break;
1743317480 }
17434- case 1402LLU: // deleter
17481+ case 1406LLU: // deleter
1743517482 {
1743617483 // throw from existsidfn
1743717484 if(!stack[base + 9])
1743817485 {
1743917486 fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17440- label = 1394LLU; // skip, variable already deleted/unscoped
17487+ label = 1398LLU; // skip, variable already deleted/unscoped
1744117488 break;
1744217489 }
1744317490 fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n");
17444- label = 1394LLU; // continue unrolling stack, delete next variable
17491+ label = 1398LLU; // continue unrolling stack, delete next variable
1744517492 break;
1744617493 }
17447- case 1403LLU: // skipped deleter
17494+ case 1407LLU: // skipped deleter
1744817495 {
1744917496 stack[base + 9] = 0;
1745017497 // call equ from existsidfn
17451- stack[base + 10LLU] = 1404LLU/*throw to this address*/;
17498+ stack[base + 10LLU] = 1408LLU/*throw to this address*/;
1745217499 stack[base + 11LLU] = base;
17453- stack[base + 12LLU] = 1405LLU;
17500+ stack[base + 12LLU] = 1409LLU;
1745417501 // arguments for call to equ
1745517502 stack[base + 14LLU] = stack[base + 7]/*id*/;
1745617503 stack[base + 15LLU] = stack[base + 2]/*searchid*/;
@@ -17459,14 +17506,14 @@
1745917506 label = 18446744073709551600LLU; // equ
1746017507 break;
1746117508 }
17462- case 1404LLU: // copy-back deleter (equ to existsidfn)
17509+ case 1408LLU: // copy-back deleter (equ to existsidfn)
1746317510 {
1746417511 fprintf(stderr, "in function existsidfn: unrolling stack, copy-back (equ to existsidfn)\n");
1746517512 // copy mutable arguments back from call to equ
17466- label = 1402LLU; // continue to roll stack
17513+ label = 1406LLU; // continue to roll stack
1746717514 break;
1746817515 }
17469- case 1405LLU: // return from equ to existsidfn
17516+ case 1409LLU: // return from equ to existsidfn
1747017517 {
1747117518 // copy mutable arguments back from call to equ
1747217519 // copy back results provided by call to equ
@@ -17473,62 +17520,62 @@
1747317520 stack[base + 9] = stack[base + 13LLU];
1747417521 if(!stack[base + 9]/*isequal*/)
1747517522 {
17476- label = 1406LLU; // jump to alternative
17523+ label = 1410LLU; // jump to alternative
1747717524 break;
1747817525 }
1747917526
1748017527 // consequent
1748117528 stack[base + 3]/*found*/ = 1;
17482- label = 1407LLU; // consequent complete
17529+ label = 1411LLU; // consequent complete
1748317530 break;
1748417531 }
17485- case 1406LLU: // alternative
17532+ case 1410LLU: // alternative
1748617533 {
17487- label = 1407LLU; // alternative complete
17534+ label = 1411LLU; // alternative complete
1748817535 break;
1748917536 }
17490- case 1407LLU: // completed if-then-else
17537+ case 1411LLU: // completed if-then-else
1749117538 {
1749217539 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1749317540 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
17494- label = 1400LLU; // case complete
17541+ label = 1404LLU; // case complete
1749517542 break;
1749617543 }
17497- case 1401LLU: // try next case
17544+ case 1405LLU: // try next case
1749817545 {
1749917546 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1750017547 exit(-1);
1750117548 }
17502- case 1400LLU: // completed switch
17549+ case 1404LLU: // completed switch
1750317550 {
17504- label = 1399LLU; // alternative complete
17551+ label = 1403LLU; // alternative complete
1750517552 break;
1750617553 }
17507- case 1399LLU: // completed if-then-else
17554+ case 1403LLU: // completed if-then-else
1750817555 {
1750917556 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
17510- label = 1396LLU; // repeat
17557+ label = 1400LLU; // repeat
1751117558 break;
1751217559 }
17513- case 1397LLU: // loop finished
17560+ case 1401LLU: // loop finished
1751417561 {
17515- label = 1409LLU; // skip deleter
17562+ label = 1413LLU; // skip deleter
1751617563 break;
1751717564 }
17518- case 1408LLU: // deleter
17565+ case 1412LLU: // deleter
1751917566 {
1752017567 // throw from existsidfn
1752117568 if(!stack[base + 0])
1752217569 {
1752317570 fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17524- label = 1394LLU; // skip, variable already deleted/unscoped
17571+ label = 1398LLU; // skip, variable already deleted/unscoped
1752517572 break;
1752617573 }
1752717574 fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n");
17528- label = 1394LLU; // continue unrolling stack, delete next variable
17575+ label = 1398LLU; // continue unrolling stack, delete next variable
1752917576 break;
1753017577 }
17531- case 1409LLU: // skipped deleter
17578+ case 1413LLU: // skipped deleter
1753217579 {
1753317580 stack[base + 0] = stack[base + 3]/*found*/;
1753417581 // return from existsidfn
@@ -17536,7 +17583,7 @@
1753617583 base = stack[base - 2];
1753717584 break;
1753817585 }
17539- case 1411LLU: // function emitcase failed
17586+ case 1415LLU: // function emitcase failed
1754017587 {
1754117588 fprintf(stderr, "function emitcase failed\n");
1754217589 label = stack[base - 3];
@@ -17543,15 +17590,15 @@
1754317590 base = stack[base - 2];
1754417591 break;
1754517592 }
17546- case 1410LLU: // emitcase
17593+ case 1414LLU: // emitcase
1754717594 {
1754817595 //#define arg0 0
1754917596 //#define arg1 1
1755017597 printf("%s", "\n case -");
1755117598 // call printnr from emitcase
17552- stack[base + 2LLU] = 1412LLU/*throw to this address*/;
17599+ stack[base + 2LLU] = 1416LLU/*throw to this address*/;
1755317600 stack[base + 3LLU] = base;
17554- stack[base + 4LLU] = 1413LLU;
17601+ stack[base + 4LLU] = 1417LLU;
1755517602 // arguments for call to printnr
1755617603 stack[base + 5LLU] = stack[base + 0]/*label*/;
1755717604 // set stack-base & callee-address
@@ -17559,21 +17606,21 @@
1755917606 label = 18446744073709551590LLU; // printnr
1756017607 break;
1756117608 }
17562- case 1412LLU: // copy-back deleter (printnr to emitcase)
17609+ case 1416LLU: // copy-back deleter (printnr to emitcase)
1756317610 {
1756417611 fprintf(stderr, "in function emitcase: unrolling stack, copy-back (printnr to emitcase)\n");
1756517612 // copy mutable arguments back from call to printnr
17566- label = 1411LLU; // continue to roll stack
17613+ label = 1415LLU; // continue to roll stack
1756717614 break;
1756817615 }
17569- case 1413LLU: // return from printnr to emitcase
17616+ case 1417LLU: // return from printnr to emitcase
1757017617 {
1757117618 // copy mutable arguments back from call to printnr
1757217619 printf("%s", ": // ");
1757317620 // call printid from emitcase
17574- stack[base + 2LLU] = 1414LLU/*throw to this address*/;
17621+ stack[base + 2LLU] = 1418LLU/*throw to this address*/;
1757517622 stack[base + 3LLU] = base;
17576- stack[base + 4LLU] = 1415LLU;
17623+ stack[base + 4LLU] = 1419LLU;
1757717624 // arguments for call to printid
1757817625 stack[base + 5LLU] = stack[base + 1]/*defid*/;
1757917626 // set stack-base & callee-address
@@ -17581,14 +17628,14 @@
1758117628 label = 18446744073709551587LLU; // printid
1758217629 break;
1758317630 }
17584- case 1414LLU: // copy-back deleter (printid to emitcase)
17631+ case 1418LLU: // copy-back deleter (printid to emitcase)
1758517632 {
1758617633 fprintf(stderr, "in function emitcase: unrolling stack, copy-back (printid to emitcase)\n");
1758717634 // copy mutable arguments back from call to printid
17588- label = 1411LLU; // continue to roll stack
17635+ label = 1415LLU; // continue to roll stack
1758917636 break;
1759017637 }
17591- case 1415LLU: // return from printid to emitcase
17638+ case 1419LLU: // return from printid to emitcase
1759217639 {
1759317640 // copy mutable arguments back from call to printid
1759417641 printf("%s", "\n {");
@@ -17597,7 +17644,7 @@
1759717644 base = stack[base - 2];
1759817645 break;
1759917646 }
17600- case 1417LLU: // function emitreturn failed
17647+ case 1421LLU: // function emitreturn failed
1760117648 {
1760217649 fprintf(stderr, "function emitreturn failed\n");
1760317650 label = stack[base - 3];
@@ -17604,7 +17651,7 @@
1760417651 base = stack[base - 2];
1760517652 break;
1760617653 }
17607- case 1416LLU: // emitreturn
17654+ case 1420LLU: // emitreturn
1760817655 {
1760917656 printf("%s", "\n");
1761017657 printf("%s", "\n label = stack[base - 1];");
@@ -17616,7 +17663,7 @@
1761617663 base = stack[base - 2];
1761717664 break;
1761817665 }
17619- case 1419LLU: // function isparam failed
17666+ case 1423LLU: // function isparam failed
1762017667 {
1762117668 fprintf(stderr, "function isparam failed\n");
1762217669 label = stack[base - 3];
@@ -17623,7 +17670,7 @@
1762317670 base = stack[base - 2];
1762417671 break;
1762517672 }
17626- case 1418LLU: // isparam
17673+ case 1422LLU: // isparam
1762717674 {
1762817675 //#define res0 0
1762917676 //#define arg0 1
@@ -17630,9 +17677,9 @@
1763017677 //#define arg1 2
1763117678 //#define arg2 3
1763217679 // call add from isparam
17633- stack[base + 5LLU] = 1420LLU/*throw to this address*/;
17680+ stack[base + 5LLU] = 1424LLU/*throw to this address*/;
1763417681 stack[base + 6LLU] = base;
17635- stack[base + 7LLU] = 1421LLU;
17682+ stack[base + 7LLU] = 1425LLU;
1763617683 // arguments for call to add
1763717684 stack[base + 9LLU] = stack[base + 1]/*rescount*/;
1763817685 stack[base + 10LLU] = stack[base + 2]/*argcount*/;
@@ -17641,22 +17688,22 @@
1764117688 label = 18446744073709551605LLU; // add
1764217689 break;
1764317690 }
17644- case 1420LLU: // copy-back deleter (add to isparam)
17691+ case 1424LLU: // copy-back deleter (add to isparam)
1764517692 {
1764617693 fprintf(stderr, "in function isparam: unrolling stack, copy-back (add to isparam)\n");
1764717694 // copy mutable arguments back from call to add
17648- label = 1419LLU; // continue to roll stack
17695+ label = 1423LLU; // continue to roll stack
1764917696 break;
1765017697 }
17651- case 1421LLU: // return from add to isparam
17698+ case 1425LLU: // return from add to isparam
1765217699 {
1765317700 // copy mutable arguments back from call to add
1765417701 // copy back results provided by call to add
1765517702 stack[base + 4] = stack[base + 8LLU];
1765617703 // call lss from isparam
17657- stack[base + 5LLU] = 1422LLU/*throw to this address*/;
17704+ stack[base + 5LLU] = 1426LLU/*throw to this address*/;
1765817705 stack[base + 6LLU] = base;
17659- stack[base + 7LLU] = 1423LLU;
17706+ stack[base + 7LLU] = 1427LLU;
1766017707 // arguments for call to lss
1766117708 stack[base + 9LLU] = stack[base + 3]/*index*/;
1766217709 stack[base + 10LLU] = stack[base + 4]/*varbase*/;
@@ -17665,14 +17712,14 @@
1766517712 label = 18446744073709551597LLU; // lss
1766617713 break;
1766717714 }
17668- case 1422LLU: // copy-back deleter (lss to isparam)
17715+ case 1426LLU: // copy-back deleter (lss to isparam)
1766917716 {
1767017717 fprintf(stderr, "in function isparam: unrolling stack, copy-back (lss to isparam)\n");
1767117718 // copy mutable arguments back from call to lss
17672- label = 1419LLU; // continue to roll stack
17719+ label = 1423LLU; // continue to roll stack
1767317720 break;
1767417721 }
17675- case 1423LLU: // return from lss to isparam
17722+ case 1427LLU: // return from lss to isparam
1767617723 {
1767717724 // copy mutable arguments back from call to lss
1767817725 // copy back results provided by call to lss
@@ -17682,7 +17729,7 @@
1768217729 base = stack[base - 2];
1768317730 break;
1768417731 }
17685- case 1425LLU: // function register failed
17732+ case 1429LLU: // function register failed
1768617733 {
1768717734 fprintf(stderr, "function register failed\n");
1768817735 label = stack[base - 3];
@@ -17689,7 +17736,7 @@
1768917736 base = stack[base - 2];
1769017737 break;
1769117738 }
17692- case 1424LLU: // register
17739+ case 1428LLU: // register
1769317740 {
1769417741 //#define arg0 0
1769517742 //#define arg1 1
@@ -17699,47 +17746,47 @@
1769917746 //#define arg5 5
1770017747 //#define arg6 6
1770117748 // call emitreturn from register
17702- stack[base + 7LLU] = 1426LLU/*throw to this address*/;
17749+ stack[base + 7LLU] = 1430LLU/*throw to this address*/;
1770317750 stack[base + 8LLU] = base;
17704- stack[base + 9LLU] = 1427LLU;
17751+ stack[base + 9LLU] = 1431LLU;
1770517752 // arguments for call to emitreturn
1770617753 // set stack-base & callee-address
1770717754 base += 10LLU;
17708- label = 1416LLU; // emitreturn
17755+ label = 1420LLU; // emitreturn
1770917756 break;
1771017757 }
17711- case 1426LLU: // copy-back deleter (emitreturn to register)
17758+ case 1430LLU: // copy-back deleter (emitreturn to register)
1771217759 {
1771317760 fprintf(stderr, "in function register: unrolling stack, copy-back (emitreturn to register)\n");
1771417761 // copy mutable arguments back from call to emitreturn
17715- label = 1425LLU; // continue to roll stack
17762+ label = 1429LLU; // continue to roll stack
1771617763 break;
1771717764 }
17718- case 1427LLU: // return from emitreturn to register
17765+ case 1431LLU: // return from emitreturn to register
1771917766 {
1772017767 // copy mutable arguments back from call to emitreturn
17721- label = 1429LLU; // skip deleter
17768+ label = 1433LLU; // skip deleter
1772217769 break;
1772317770 }
17724- case 1428LLU: // deleter
17771+ case 1432LLU: // deleter
1772517772 {
1772617773 // throw from register
1772717774 if(!stack[base + 7])
1772817775 {
1772917776 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [result] \n");
17730- label = 1425LLU; // skip, variable already deleted/unscoped
17777+ label = 1429LLU; // skip, variable already deleted/unscoped
1773117778 break;
1773217779 }
1773317780 fprintf(stderr, "in function register: unrolling stack, variable [result] \n");
1773417781 // delete list
17735- label = 1430LLU; // start to repeat
17782+ label = 1434LLU; // start to repeat
1773617783 break;
1773717784 }
17738- case 1430LLU: // repeat from here
17785+ case 1434LLU: // repeat from here
1773917786 {
1774017787 if(!stack[base + 7])
1774117788 {
17742- label = 1431LLU; // break loop
17789+ label = 1435LLU; // break loop
1774317790 break;
1774417791 }
1774517792
@@ -17750,7 +17797,7 @@
1775017797 newstack[0] = (uint64_t)stack; // backup stack location
1775117798 newstack[1] = 1234567890;
1775217799 newstack[2] = base;
17753- newstack[3] = 1432LLU;
17800+ newstack[3] = 1436LLU;
1775417801 stack = newstack;
1775517802 // set stack-base & callee-address
1775617803 base = 4/*deloffset*/;
@@ -17757,7 +17804,7 @@
1775717804 label = 382LLU; // ~result
1775817805 break;
1775917806 }
17760- case 1432LLU: // return from ~result to register
17807+ case 1436LLU: // return from ~result to register
1776117808 {
1776217809 stack = (uint64_t *)stack[0];
1776317810 // releasing toplevel container
@@ -17768,35 +17815,35 @@
1776817815 stack[base + 7] = (uint64_t)list->next;
1776917816 Free(1, sizeof(struct listnode), list);
1777017817 }
17771- label = 1430LLU; // repeat
17818+ label = 1434LLU; // repeat
1777217819 break;
1777317820 }
17774- case 1431LLU: // loop finished
17821+ case 1435LLU: // loop finished
1777517822 {
17776- label = 1425LLU; // continue unrolling stack, delete next variable
17823+ label = 1429LLU; // continue unrolling stack, delete next variable
1777717824 break;
1777817825 }
17779- case 1429LLU: // skipped deleter
17826+ case 1433LLU: // skipped deleter
1778017827 {
1778117828 stack[base + 7] = 0;
1778217829 stack[base + 8] = stack[base + 0]/*rescount*/;
1778317830
17784- label = 1433LLU; // start to repeat
17831+ label = 1437LLU; // start to repeat
1778517832 break;
1778617833 }
17787- case 1433LLU: // repeat from here
17834+ case 1437LLU: // repeat from here
1778817835 {
1778917836 if(!stack[base + 8]--)
1779017837 {
17791- label = 1434LLU; // break loop
17838+ label = 1438LLU; // break loop
1779217839 break;
1779317840 }
1779417841
1779517842 // loop body
1779617843 // call mktypename from register
17797- stack[base + 10LLU] = 1435LLU/*throw to this address*/;
17844+ stack[base + 10LLU] = 1439LLU/*throw to this address*/;
1779817845 stack[base + 11LLU] = base;
17799- stack[base + 12LLU] = 1436LLU;
17846+ stack[base + 12LLU] = 1440LLU;
1780017847 // arguments for call to mktypename
1780117848 stack[base + 14LLU] = 881834713755418624LLU;
1780217849 // set stack-base & callee-address
@@ -17804,47 +17851,47 @@
1780417851 label = 299LLU; // mktypename
1780517852 break;
1780617853 }
17807- case 1435LLU: // copy-back deleter (mktypename to register)
17854+ case 1439LLU: // copy-back deleter (mktypename to register)
1780817855 {
1780917856 fprintf(stderr, "in function register: unrolling stack, copy-back (mktypename to register)\n");
1781017857 // copy mutable arguments back from call to mktypename
17811- label = 1428LLU; // continue to roll stack
17858+ label = 1432LLU; // continue to roll stack
1781217859 break;
1781317860 }
17814- case 1436LLU: // return from mktypename to register
17861+ case 1440LLU: // return from mktypename to register
1781517862 {
1781617863 // copy mutable arguments back from call to mktypename
1781717864 // copy back results provided by call to mktypename
1781817865 stack[base + 9] = stack[base + 13LLU];
17819- label = 1438LLU; // skip deleter
17866+ label = 1442LLU; // skip deleter
1782017867 break;
1782117868 }
17822- case 1437LLU: // deleter
17869+ case 1441LLU: // deleter
1782317870 {
1782417871 // throw from register
1782517872 if(!stack[base + 10])
1782617873 {
1782717874 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17828- label = 1428LLU; // skip, variable already deleted/unscoped
17875+ label = 1432LLU; // skip, variable already deleted/unscoped
1782917876 break;
1783017877 }
1783117878 fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
17832- label = 1428LLU; // continue unrolling stack, delete next variable
17879+ label = 1432LLU; // continue unrolling stack, delete next variable
1783317880 break;
1783417881 }
17835- case 1438LLU: // skipped deleter
17882+ case 1442LLU: // skipped deleter
1783617883 {
1783717884 stack[base + 10] = 1;
17838- label = 1440LLU; // skip deleter
17885+ label = 1444LLU; // skip deleter
1783917886 break;
1784017887 }
17841- case 1439LLU: // deleter
17888+ case 1443LLU: // deleter
1784217889 {
1784317890 // throw from register
1784417891 if(!stack[base + 11])
1784517892 {
1784617893 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable result \n");
17847- label = 1437LLU; // skip, variable already deleted/unscoped
17894+ label = 1441LLU; // skip, variable already deleted/unscoped
1784817895 break;
1784917896 }
1785017897 fprintf(stderr, "in function register: unrolling stack, variable result \n");
@@ -17854,7 +17901,7 @@
1785417901 newstack[0] = (uint64_t)stack; // backup stack location
1785517902 newstack[1] = 1234567890;
1785617903 newstack[2] = base;
17857- newstack[3] = 1441LLU;
17904+ newstack[3] = 1445LLU;
1785817905 stack = newstack;
1785917906 // set stack-base & callee-address
1786017907 base = 4/*deloffset*/;
@@ -17861,21 +17908,21 @@
1786117908 label = 382LLU; // ~result
1786217909 break;
1786317910 }
17864- case 1441LLU: // return from ~result to register
17911+ case 1445LLU: // return from ~result to register
1786517912 {
1786617913 stack = (uint64_t *)stack[0];
1786717914 // releasing toplevel container
1786817915 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 11] - sizeof(uint64_t) * 4));
1786917916
17870- label = 1437LLU; // continue unrolling stack, delete next variable
17917+ label = 1441LLU; // continue unrolling stack, delete next variable
1787117918 break;
1787217919 }
17873- case 1440LLU: // skipped deleter
17920+ case 1444LLU: // skipped deleter
1787417921 {
1787517922 // construct result.result
1787617923 if(!(stack[base + 11] = construct(2)))
1787717924 {
17878- label = 1437LLU; // throw: begin to unroll stack
17925+ label = 1441LLU; // throw: begin to unroll stack
1787917926 break;
1788017927 }
1788117928
@@ -17894,33 +17941,33 @@
1789417941 stack[base + 7]/*fnrestypes*/ = (uint64_t)list;
1789517942 MOVE(&list->data, &stack[base + 11]/*result*/);
1789617943 }
17897- label = 1433LLU; // repeat
17944+ label = 1437LLU; // repeat
1789817945 break;
1789917946 }
17900- case 1434LLU: // loop finished
17947+ case 1438LLU: // loop finished
1790117948 {
17902- label = 1443LLU; // skip deleter
17949+ label = 1447LLU; // skip deleter
1790317950 break;
1790417951 }
17905- case 1442LLU: // deleter
17952+ case 1446LLU: // deleter
1790617953 {
1790717954 // throw from register
1790817955 if(!stack[base + 9])
1790917956 {
1791017957 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [param] \n");
17911- label = 1428LLU; // skip, variable already deleted/unscoped
17958+ label = 1432LLU; // skip, variable already deleted/unscoped
1791217959 break;
1791317960 }
1791417961 fprintf(stderr, "in function register: unrolling stack, variable [param] \n");
1791517962 // delete list
17916- label = 1444LLU; // start to repeat
17963+ label = 1448LLU; // start to repeat
1791717964 break;
1791817965 }
17919- case 1444LLU: // repeat from here
17966+ case 1448LLU: // repeat from here
1792017967 {
1792117968 if(!stack[base + 9])
1792217969 {
17923- label = 1445LLU; // break loop
17970+ label = 1449LLU; // break loop
1792417971 break;
1792517972 }
1792617973
@@ -17931,7 +17978,7 @@
1793117978 newstack[0] = (uint64_t)stack; // backup stack location
1793217979 newstack[1] = 1234567890;
1793317980 newstack[2] = base;
17934- newstack[3] = 1446LLU;
17981+ newstack[3] = 1450LLU;
1793517982 stack = newstack;
1793617983 // set stack-base & callee-address
1793717984 base = 4/*deloffset*/;
@@ -17938,7 +17985,7 @@
1793817985 label = 400LLU; // ~param
1793917986 break;
1794017987 }
17941- case 1446LLU: // return from ~param to register
17988+ case 1450LLU: // return from ~param to register
1794217989 {
1794317990 stack = (uint64_t *)stack[0];
1794417991 // releasing toplevel container
@@ -17949,35 +17996,35 @@
1794917996 stack[base + 9] = (uint64_t)list->next;
1795017997 Free(1, sizeof(struct listnode), list);
1795117998 }
17952- label = 1444LLU; // repeat
17999+ label = 1448LLU; // repeat
1795318000 break;
1795418001 }
17955- case 1445LLU: // loop finished
18002+ case 1449LLU: // loop finished
1795618003 {
17957- label = 1428LLU; // continue unrolling stack, delete next variable
18004+ label = 1432LLU; // continue unrolling stack, delete next variable
1795818005 break;
1795918006 }
17960- case 1443LLU: // skipped deleter
18007+ case 1447LLU: // skipped deleter
1796118008 {
1796218009 stack[base + 9] = 0;
1796318010 stack[base + 10] = stack[base + 1]/*argcount*/;
1796418011
17965- label = 1447LLU; // start to repeat
18012+ label = 1451LLU; // start to repeat
1796618013 break;
1796718014 }
17968- case 1447LLU: // repeat from here
18015+ case 1451LLU: // repeat from here
1796918016 {
1797018017 if(!stack[base + 10]--)
1797118018 {
17972- label = 1448LLU; // break loop
18019+ label = 1452LLU; // break loop
1797318020 break;
1797418021 }
1797518022
1797618023 // loop body
1797718024 // call mktypename from register
17978- stack[base + 12LLU] = 1449LLU/*throw to this address*/;
18025+ stack[base + 12LLU] = 1453LLU/*throw to this address*/;
1797918026 stack[base + 13LLU] = base;
17980- stack[base + 14LLU] = 1450LLU;
18027+ stack[base + 14LLU] = 1454LLU;
1798118028 // arguments for call to mktypename
1798218029 stack[base + 16LLU] = 881834713755418624LLU;
1798318030 // set stack-base & callee-address
@@ -17985,22 +18032,22 @@
1798518032 label = 299LLU; // mktypename
1798618033 break;
1798718034 }
17988- case 1449LLU: // copy-back deleter (mktypename to register)
18035+ case 1453LLU: // copy-back deleter (mktypename to register)
1798918036 {
1799018037 fprintf(stderr, "in function register: unrolling stack, copy-back (mktypename to register)\n");
1799118038 // copy mutable arguments back from call to mktypename
17992- label = 1442LLU; // continue to roll stack
18039+ label = 1446LLU; // continue to roll stack
1799318040 break;
1799418041 }
17995- case 1450LLU: // return from mktypename to register
18042+ case 1454LLU: // return from mktypename to register
1799618043 {
1799718044 // copy mutable arguments back from call to mktypename
1799818045 // copy back results provided by call to mktypename
1799918046 stack[base + 11] = stack[base + 15LLU];
1800018047 // call idwithnr from register
18001- stack[base + 13LLU] = 1451LLU/*throw to this address*/;
18048+ stack[base + 13LLU] = 1455LLU/*throw to this address*/;
1800218049 stack[base + 14LLU] = base;
18003- stack[base + 15LLU] = 1452LLU;
18050+ stack[base + 15LLU] = 1456LLU;
1800418051 // arguments for call to idwithnr
1800518052 stack[base + 17LLU] = 517219065798852608LLU;
1800618053 stack[base + 18LLU] = stack[base + 10]/*ARGCOUNT*/;
@@ -18009,28 +18056,28 @@
1800918056 label = 18446744073709551579LLU; // idwithnr
1801018057 break;
1801118058 }
18012- case 1451LLU: // copy-back deleter (idwithnr to register)
18059+ case 1455LLU: // copy-back deleter (idwithnr to register)
1801318060 {
1801418061 fprintf(stderr, "in function register: unrolling stack, copy-back (idwithnr to register)\n");
1801518062 // copy mutable arguments back from call to idwithnr
18016- label = 1442LLU; // continue to roll stack
18063+ label = 1446LLU; // continue to roll stack
1801718064 break;
1801818065 }
18019- case 1452LLU: // return from idwithnr to register
18066+ case 1456LLU: // return from idwithnr to register
1802018067 {
1802118068 // copy mutable arguments back from call to idwithnr
1802218069 // copy back results provided by call to idwithnr
1802318070 stack[base + 12] = stack[base + 16LLU];
18024- label = 1454LLU; // skip deleter
18071+ label = 1458LLU; // skip deleter
1802518072 break;
1802618073 }
18027- case 1453LLU: // deleter
18074+ case 1457LLU: // deleter
1802818075 {
1802918076 // throw from register
1803018077 if(!stack[base + 13])
1803118078 {
1803218079 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable typeid \n");
18033- label = 1442LLU; // skip, variable already deleted/unscoped
18080+ label = 1446LLU; // skip, variable already deleted/unscoped
1803418081 break;
1803518082 }
1803618083 fprintf(stderr, "in function register: unrolling stack, variable typeid \n");
@@ -18040,7 +18087,7 @@
1804018087 newstack[0] = (uint64_t)stack; // backup stack location
1804118088 newstack[1] = 1234567890;
1804218089 newstack[2] = base;
18043- newstack[3] = 1455LLU;
18090+ newstack[3] = 1459LLU;
1804418091 stack = newstack;
1804518092 // set stack-base & callee-address
1804618093 base = 4/*deloffset*/;
@@ -18047,21 +18094,21 @@
1804718094 label = 346LLU; // ~typeid
1804818095 break;
1804918096 }
18050- case 1455LLU: // return from ~typeid to register
18097+ case 1459LLU: // return from ~typeid to register
1805118098 {
1805218099 stack = (uint64_t *)stack[0];
1805318100 // releasing toplevel container
1805418101 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4));
1805518102
18056- label = 1442LLU; // continue unrolling stack, delete next variable
18103+ label = 1446LLU; // continue unrolling stack, delete next variable
1805718104 break;
1805818105 }
18059- case 1454LLU: // skipped deleter
18106+ case 1458LLU: // skipped deleter
1806018107 {
1806118108 // construct typeid.typeid
1806218109 if(!(stack[base + 13] = construct(2)))
1806318110 {
18064- label = 1442LLU; // throw: begin to unroll stack
18111+ label = 1446LLU; // throw: begin to unroll stack
1806518112 break;
1806618113 }
1806718114
@@ -18069,35 +18116,35 @@
1806918116 ((uint64_t *)stack[base + 13])[0] = 0;
1807018117 INIT(&(((uint64_t **)(stack[base + 13]))[1][0]), &stack[base + 11]/*type*/);
1807118118 (((uint64_t **)(stack[base + 13]))[1][1]) = stack[base + 12]/*id*/;
18072- label = 1457LLU; // skip deleter
18119+ label = 1461LLU; // skip deleter
1807318120 break;
1807418121 }
18075- case 1456LLU: // deleter
18122+ case 1460LLU: // deleter
1807618123 {
1807718124 // throw from register
1807818125 if(!stack[base + 14])
1807918126 {
1808018127 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18081- label = 1453LLU; // skip, variable already deleted/unscoped
18128+ label = 1457LLU; // skip, variable already deleted/unscoped
1808218129 break;
1808318130 }
1808418131 fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18085- label = 1453LLU; // continue unrolling stack, delete next variable
18132+ label = 1457LLU; // continue unrolling stack, delete next variable
1808618133 break;
1808718134 }
18088- case 1457LLU: // skipped deleter
18135+ case 1461LLU: // skipped deleter
1808918136 {
1809018137 stack[base + 14] = 0;
18091- label = 1459LLU; // skip deleter
18138+ label = 1463LLU; // skip deleter
1809218139 break;
1809318140 }
18094- case 1458LLU: // deleter
18141+ case 1462LLU: // deleter
1809518142 {
1809618143 // throw from register
1809718144 if(!stack[base + 15])
1809818145 {
1809918146 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable param \n");
18100- label = 1456LLU; // skip, variable already deleted/unscoped
18147+ label = 1460LLU; // skip, variable already deleted/unscoped
1810118148 break;
1810218149 }
1810318150 fprintf(stderr, "in function register: unrolling stack, variable param \n");
@@ -18107,7 +18154,7 @@
1810718154 newstack[0] = (uint64_t)stack; // backup stack location
1810818155 newstack[1] = 1234567890;
1810918156 newstack[2] = base;
18110- newstack[3] = 1460LLU;
18157+ newstack[3] = 1464LLU;
1811118158 stack = newstack;
1811218159 // set stack-base & callee-address
1811318160 base = 4/*deloffset*/;
@@ -18114,21 +18161,21 @@
1811418161 label = 400LLU; // ~param
1811518162 break;
1811618163 }
18117- case 1460LLU: // return from ~param to register
18164+ case 1464LLU: // return from ~param to register
1811818165 {
1811918166 stack = (uint64_t *)stack[0];
1812018167 // releasing toplevel container
1812118168 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4));
1812218169
18123- label = 1456LLU; // continue unrolling stack, delete next variable
18170+ label = 1460LLU; // continue unrolling stack, delete next variable
1812418171 break;
1812518172 }
18126- case 1459LLU: // skipped deleter
18173+ case 1463LLU: // skipped deleter
1812718174 {
1812818175 // construct param.param
1812918176 if(!(stack[base + 15] = construct(2)))
1813018177 {
18131- label = 1456LLU; // throw: begin to unroll stack
18178+ label = 1460LLU; // throw: begin to unroll stack
1813218179 break;
1813318180 }
1813418181
@@ -18147,53 +18194,53 @@
1814718194 stack[base + 9]/*fnargtypes*/ = (uint64_t)list;
1814818195 MOVE(&list->data, &stack[base + 15]/*param*/);
1814918196 }
18150- label = 1447LLU; // repeat
18197+ label = 1451LLU; // repeat
1815118198 break;
1815218199 }
18153- case 1448LLU: // loop finished
18200+ case 1452LLU: // loop finished
1815418201 {
18155- label = 1462LLU; // skip deleter
18202+ label = 1466LLU; // skip deleter
1815618203 break;
1815718204 }
18158- case 1461LLU: // deleter
18205+ case 1465LLU: // deleter
1815918206 {
1816018207 // throw from register
1816118208 if(!stack[base + 11])
1816218209 {
1816318210 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18164- label = 1442LLU; // skip, variable already deleted/unscoped
18211+ label = 1446LLU; // skip, variable already deleted/unscoped
1816518212 break;
1816618213 }
1816718214 fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18168- label = 1442LLU; // continue unrolling stack, delete next variable
18215+ label = 1446LLU; // continue unrolling stack, delete next variable
1816918216 break;
1817018217 }
18171- case 1462LLU: // skipped deleter
18218+ case 1466LLU: // skipped deleter
1817218219 {
1817318220 stack[base + 11] = 0;
18174- label = 1464LLU; // skip deleter
18221+ label = 1468LLU; // skip deleter
1817518222 break;
1817618223 }
18177- case 1463LLU: // deleter
18224+ case 1467LLU: // deleter
1817818225 {
1817918226 // throw from register
1818018227 if(!stack[base + 12])
1818118228 {
1818218229 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18183- label = 1461LLU; // skip, variable already deleted/unscoped
18230+ label = 1465LLU; // skip, variable already deleted/unscoped
1818418231 break;
1818518232 }
1818618233 fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18187- label = 1461LLU; // continue unrolling stack, delete next variable
18234+ label = 1465LLU; // continue unrolling stack, delete next variable
1818818235 break;
1818918236 }
18190- case 1464LLU: // skipped deleter
18237+ case 1468LLU: // skipped deleter
1819118238 {
1819218239 stack[base + 12] = 0;
1819318240 // call sub from register
18194- stack[base + 13LLU] = 1465LLU/*throw to this address*/;
18241+ stack[base + 13LLU] = 1469LLU/*throw to this address*/;
1819518242 stack[base + 14LLU] = base;
18196- stack[base + 15LLU] = 1466LLU;
18243+ stack[base + 15LLU] = 1470LLU;
1819718244 // arguments for call to sub
1819818245 stack[base + 17LLU] = stack[base + 12]/*fnlabel*/;
1819918246 stack[base + 18LLU] = stack[base + 5]/*defcount*/;
@@ -18202,22 +18249,22 @@
1820218249 label = 18446744073709551604LLU; // sub
1820318250 break;
1820418251 }
18205- case 1465LLU: // copy-back deleter (sub to register)
18252+ case 1469LLU: // copy-back deleter (sub to register)
1820618253 {
1820718254 fprintf(stderr, "in function register: unrolling stack, copy-back (sub to register)\n");
1820818255 // copy mutable arguments back from call to sub
18209- label = 1463LLU; // continue to roll stack
18256+ label = 1467LLU; // continue to roll stack
1821018257 break;
1821118258 }
18212- case 1466LLU: // return from sub to register
18259+ case 1470LLU: // return from sub to register
1821318260 {
1821418261 // copy mutable arguments back from call to sub
1821518262 // copy back results provided by call to sub
1821618263 stack[base + 12] = stack[base + 16LLU];
1821718264 // call sub from register
18218- stack[base + 13LLU] = 1467LLU/*throw to this address*/;
18265+ stack[base + 13LLU] = 1471LLU/*throw to this address*/;
1821918266 stack[base + 14LLU] = base;
18220- stack[base + 15LLU] = 1468LLU;
18267+ stack[base + 15LLU] = 1472LLU;
1822118268 // arguments for call to sub
1822218269 stack[base + 17LLU] = stack[base + 12]/*fnlabel*/;
1822318270 stack[base + 18LLU] = 1LLU;
@@ -18226,38 +18273,57 @@
1822618273 label = 18446744073709551604LLU; // sub
1822718274 break;
1822818275 }
18229- case 1467LLU: // copy-back deleter (sub to register)
18276+ case 1471LLU: // copy-back deleter (sub to register)
1823018277 {
1823118278 fprintf(stderr, "in function register: unrolling stack, copy-back (sub to register)\n");
1823218279 // copy mutable arguments back from call to sub
18233- label = 1463LLU; // continue to roll stack
18280+ label = 1467LLU; // continue to roll stack
1823418281 break;
1823518282 }
18236- case 1468LLU: // return from sub to register
18283+ case 1472LLU: // return from sub to register
1823718284 {
1823818285 // copy mutable arguments back from call to sub
1823918286 // copy back results provided by call to sub
1824018287 stack[base + 12] = stack[base + 16LLU];
18241- label = 1470LLU; // skip deleter
18288+ label = 1474LLU; // skip deleter
1824218289 break;
1824318290 }
18244- case 1469LLU: // deleter
18291+ case 1473LLU: // deleter
1824518292 {
1824618293 // throw from register
1824718294 if(!stack[base + 13])
1824818295 {
18296+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18297+ label = 1467LLU; // skip, variable already deleted/unscoped
18298+ break;
18299+ }
18300+ fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18301+ label = 1467LLU; // continue unrolling stack, delete next variable
18302+ break;
18303+ }
18304+ case 1474LLU: // skipped deleter
18305+ {
18306+ stack[base + 13] = 0;
18307+ label = 1476LLU; // skip deleter
18308+ break;
18309+ }
18310+ case 1475LLU: // deleter
18311+ {
18312+ // throw from register
18313+ if(!stack[base + 14])
18314+ {
1824918315 fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable fndef \n");
18250- label = 1463LLU; // skip, variable already deleted/unscoped
18316+ label = 1473LLU; // skip, variable already deleted/unscoped
1825118317 break;
1825218318 }
1825318319 fprintf(stderr, "in function register: unrolling stack, variable fndef \n");
1825418320
18255- uint64_t *newstack = (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4);
18321+ uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4);
1825618322 // call ~fndef from register
1825718323 newstack[0] = (uint64_t)stack; // backup stack location
1825818324 newstack[1] = 1234567890;
1825918325 newstack[2] = base;
18260- newstack[3] = 1471LLU;
18326+ newstack[3] = 1477LLU;
1826118327 stack = newstack;
1826218328 // set stack-base & callee-address
1826318329 base = 4/*deloffset*/;
@@ -18264,33 +18330,34 @@
1826418330 label = 1273LLU; // ~fndef
1826518331 break;
1826618332 }
18267- case 1471LLU: // return from ~fndef to register
18333+ case 1477LLU: // return from ~fndef to register
1826818334 {
1826918335 stack = (uint64_t *)stack[0];
1827018336 // releasing toplevel container
18271- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4));
18337+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1827218338
18273- label = 1463LLU; // continue unrolling stack, delete next variable
18339+ label = 1473LLU; // continue unrolling stack, delete next variable
1827418340 break;
1827518341 }
18276- case 1470LLU: // skipped deleter
18342+ case 1476LLU: // skipped deleter
1827718343 {
1827818344 // construct fndef.fndef
18279- if(!(stack[base + 13] = construct(7)))
18345+ if(!(stack[base + 14] = construct(8)))
1828018346 {
18281- label = 1463LLU; // throw: begin to unroll stack
18347+ label = 1473LLU; // throw: begin to unroll stack
1828218348 break;
1828318349 }
1828418350
1828518351 // consequent
18286- ((uint64_t *)stack[base + 13])[0] = 0;
18287- (((uint64_t **)(stack[base + 13]))[1][0]) = stack[base + 12]/*fnlabel*/;
18288- INIT(&(((uint64_t **)(stack[base + 13]))[1][1]), &stack[base + 7]/*fnrestypes*/);
18289- INIT(&(((uint64_t **)(stack[base + 13]))[1][2]), &stack[base + 9]/*fnargtypes*/);
18290- (((uint64_t **)(stack[base + 13]))[1][3]) = stack[base + 2]/*maxcount*/;
18291- (((uint64_t **)(stack[base + 13]))[1][4]) = stack[base + 3]/*fnid*/;
18292- (((uint64_t **)(stack[base + 13]))[1][5]) = stack[base + 11]/*fnrec*/;
18293- (((uint64_t **)(stack[base + 13]))[1][6]) = stack[base + 6]/*fallible*/;
18352+ ((uint64_t *)stack[base + 14])[0] = 0;
18353+ (((uint64_t **)(stack[base + 14]))[1][0]) = stack[base + 12]/*fnlabel*/;
18354+ INIT(&(((uint64_t **)(stack[base + 14]))[1][1]), &stack[base + 7]/*fnrestypes*/);
18355+ INIT(&(((uint64_t **)(stack[base + 14]))[1][2]), &stack[base + 9]/*fnargtypes*/);
18356+ (((uint64_t **)(stack[base + 14]))[1][3]) = stack[base + 2]/*maxcount*/;
18357+ (((uint64_t **)(stack[base + 14]))[1][4]) = stack[base + 3]/*fnid*/;
18358+ (((uint64_t **)(stack[base + 14]))[1][5]) = stack[base + 11]/*fnrec*/;
18359+ (((uint64_t **)(stack[base + 14]))[1][6]) = stack[base + 6]/*fallible*/;
18360+ (((uint64_t **)(stack[base + 14]))[1][7]) = stack[base + 13]/*canthrow*/;
1829418361 {
1829518362 struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
1829618363 if(!list)
@@ -18300,52 +18367,52 @@
1830018367 }
1830118368 list->next = (struct listnode *)stack[base + 4]/*fndefs*/;
1830218369 stack[base + 4]/*fndefs*/ = (uint64_t)list;
18303- MOVE(&list->data, &stack[base + 13]/*fndef*/);
18370+ MOVE(&list->data, &stack[base + 14]/*fndef*/);
1830418371 }
1830518372 // call add from register
18306- stack[base + 14LLU] = 1472LLU/*throw to this address*/;
18307- stack[base + 15LLU] = base;
18308- stack[base + 16LLU] = 1473LLU;
18373+ stack[base + 15LLU] = 1478LLU/*throw to this address*/;
18374+ stack[base + 16LLU] = base;
18375+ stack[base + 17LLU] = 1479LLU;
1830918376 // arguments for call to add
18310- stack[base + 18LLU] = stack[base + 5]/*defcount*/;
18311- stack[base + 19LLU] = 1LLU;
18377+ stack[base + 19LLU] = stack[base + 5]/*defcount*/;
18378+ stack[base + 20LLU] = 1LLU;
1831218379 // set stack-base & callee-address
18313- base += 17LLU;
18380+ base += 18LLU;
1831418381 label = 18446744073709551605LLU; // add
1831518382 break;
1831618383 }
18317- case 1472LLU: // copy-back deleter (add to register)
18384+ case 1478LLU: // copy-back deleter (add to register)
1831818385 {
1831918386 fprintf(stderr, "in function register: unrolling stack, copy-back (add to register)\n");
1832018387 // copy mutable arguments back from call to add
18321- label = 1469LLU; // continue to roll stack
18388+ label = 1475LLU; // continue to roll stack
1832218389 break;
1832318390 }
18324- case 1473LLU: // return from add to register
18391+ case 1479LLU: // return from add to register
1832518392 {
1832618393 // copy mutable arguments back from call to add
1832718394 // copy back results provided by call to add
18328- stack[base + 5] = stack[base + 17LLU];
18395+ stack[base + 5] = stack[base + 18LLU];
1832918396 // call emitcase from register
18330- stack[base + 14LLU] = 1474LLU/*throw to this address*/;
18331- stack[base + 15LLU] = base;
18332- stack[base + 16LLU] = 1475LLU;
18397+ stack[base + 15LLU] = 1480LLU/*throw to this address*/;
18398+ stack[base + 16LLU] = base;
18399+ stack[base + 17LLU] = 1481LLU;
1833318400 // arguments for call to emitcase
18334- stack[base + 17LLU] = stack[base + 5]/*defcount*/;
18335- stack[base + 18LLU] = stack[base + 3]/*fnid*/;
18401+ stack[base + 18LLU] = stack[base + 5]/*defcount*/;
18402+ stack[base + 19LLU] = stack[base + 3]/*fnid*/;
1833618403 // set stack-base & callee-address
18337- base += 17LLU;
18338- label = 1410LLU; // emitcase
18404+ base += 18LLU;
18405+ label = 1414LLU; // emitcase
1833918406 break;
1834018407 }
18341- case 1474LLU: // copy-back deleter (emitcase to register)
18408+ case 1480LLU: // copy-back deleter (emitcase to register)
1834218409 {
1834318410 fprintf(stderr, "in function register: unrolling stack, copy-back (emitcase to register)\n");
1834418411 // copy mutable arguments back from call to emitcase
18345- label = 1469LLU; // continue to roll stack
18412+ label = 1475LLU; // continue to roll stack
1834618413 break;
1834718414 }
18348- case 1475LLU: // return from emitcase to register
18415+ case 1481LLU: // return from emitcase to register
1834918416 {
1835018417 // copy mutable arguments back from call to emitcase
1835118418 // return from register
@@ -18353,7 +18420,7 @@
1835318420 base = stack[base - 2];
1835418421 break;
1835518422 }
18356- case 1477LLU: // function linkthrow failed
18423+ case 1483LLU: // function linkthrow failed
1835718424 {
1835818425 fprintf(stderr, "function linkthrow failed\n");
1835918426 label = stack[base - 3];
@@ -18360,13 +18427,13 @@
1836018427 base = stack[base - 2];
1836118428 break;
1836218429 }
18363- case 1476LLU: // linkthrow
18430+ case 1482LLU: // linkthrow
1836418431 {
1836518432 //#define arg0 0
1836618433 //#define arg1 1
1836718434 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
1836818435 {
18369- label = 1479LLU; // jump to alternative
18436+ label = 1485LLU; // jump to alternative
1837018437 break;
1837118438 }
1837218439
@@ -18377,15 +18444,15 @@
1837718444 stack[base + 2]/*labelthrow*/ = stack[base + 1]/*labelfail*/;
1837818445 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
1837918446 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
18380- label = 1478LLU; // case complete
18447+ label = 1484LLU; // case complete
1838118448 break;
1838218449 }
18383- case 1479LLU: // try next case
18450+ case 1485LLU: // try next case
1838418451 {
1838518452 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1838618453 exit(-1);
1838718454 }
18388- case 1478LLU: // completed switch
18455+ case 1484LLU: // completed switch
1838918456 {
1839018457 // return from linkthrow
1839118458 label = stack[base - 1];
@@ -18392,7 +18459,7 @@
1839218459 base = stack[base - 2];
1839318460 break;
1839418461 }
18395- case 1481LLU: // function emitthrow failed
18462+ case 1487LLU: // function emitthrow failed
1839618463 {
1839718464 fprintf(stderr, "function emitthrow failed\n");
1839818465 label = stack[base - 3];
@@ -18399,13 +18466,13 @@
1839918466 base = stack[base - 2];
1840018467 break;
1840118468 }
18402- case 1480LLU: // emitthrow
18469+ case 1486LLU: // emitthrow
1840318470 {
1840418471 //#define arg0 0
1840518472 printf("%s", "\n {");
1840618473 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
1840718474 {
18408- label = 1483LLU; // jump to alternative
18475+ label = 1489LLU; // jump to alternative
1840918476 break;
1841018477 }
1841118478
@@ -18415,9 +18482,9 @@
1841518482 // case
1841618483 printf("%s", "\n label = ");
1841718484 // call printnr from emitthrow
18418- stack[base + 3LLU] = 1484LLU/*throw to this address*/;
18485+ stack[base + 3LLU] = 1490LLU/*throw to this address*/;
1841918486 stack[base + 4LLU] = base;
18420- stack[base + 5LLU] = 1485LLU;
18487+ stack[base + 5LLU] = 1491LLU;
1842118488 // arguments for call to printnr
1842218489 stack[base + 6LLU] = stack[base + 1]/*labelthrow*/;
1842318490 // set stack-base & callee-address
@@ -18425,28 +18492,28 @@
1842518492 label = 18446744073709551590LLU; // printnr
1842618493 break;
1842718494 }
18428- case 1484LLU: // copy-back deleter (printnr to emitthrow)
18495+ case 1490LLU: // copy-back deleter (printnr to emitthrow)
1842918496 {
1843018497 fprintf(stderr, "in function emitthrow: unrolling stack, copy-back (printnr to emitthrow)\n");
1843118498 // copy mutable arguments back from call to printnr
18432- label = 1481LLU; // continue to roll stack
18499+ label = 1487LLU; // continue to roll stack
1843318500 break;
1843418501 }
18435- case 1485LLU: // return from printnr to emitthrow
18502+ case 1491LLU: // return from printnr to emitthrow
1843618503 {
1843718504 // copy mutable arguments back from call to printnr
1843818505 printf("%s", "LLU; // throw: begin to unroll stack");
1843918506 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
1844018507 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
18441- label = 1482LLU; // case complete
18508+ label = 1488LLU; // case complete
1844218509 break;
1844318510 }
18444- case 1483LLU: // try next case
18511+ case 1489LLU: // try next case
1844518512 {
1844618513 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1844718514 exit(-1);
1844818515 }
18449- case 1482LLU: // completed switch
18516+ case 1488LLU: // completed switch
1845018517 {
1845118518 printf("%s", "\n break;");
1845218519 printf("%s", "\n }");
@@ -18456,7 +18523,7 @@
1845618523 base = stack[base - 2];
1845718524 break;
1845818525 }
18459- case 1487LLU: // function ProcCall failed
18526+ case 1493LLU: // function ProcCall failed
1846018527 {
1846118528 fprintf(stderr, "function ProcCall failed\n");
1846218529 label = stack[base - 3];
@@ -18463,7 +18530,7 @@
1846318530 base = stack[base - 2];
1846418531 break;
1846518532 }
18466- case 1486LLU: // ProcCall
18533+ case 1492LLU: // ProcCall
1846718534 {
1846818535 //#define arg0 0
1846918536 //#define arg1 1
@@ -18482,58 +18549,59 @@
1848218549 //#define arg14 14
1848318550 //#define arg15 15
1848418551 //#define arg16 16
18485- label = 1489LLU; // skip deleter
18552+//#define arg17 17
18553+ label = 1495LLU; // skip deleter
1848618554 break;
1848718555 }
18488- case 1488LLU: // deleter
18556+ case 1494LLU: // deleter
1848918557 {
1849018558 // throw from ProcCall
18491- if(!stack[base + 17])
18559+ if(!stack[base + 18])
1849218560 {
1849318561 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18494- label = 1487LLU; // skip, variable already deleted/unscoped
18562+ label = 1493LLU; // skip, variable already deleted/unscoped
1849518563 break;
1849618564 }
1849718565 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18498- label = 1487LLU; // continue unrolling stack, delete next variable
18566+ label = 1493LLU; // continue unrolling stack, delete next variable
1849918567 break;
1850018568 }
18501- case 1489LLU: // skipped deleter
18569+ case 1495LLU: // skipped deleter
1850218570 {
18503- stack[base + 17] = 0;
18504- label = 1491LLU; // skip deleter
18571+ stack[base + 18] = 0;
18572+ label = 1497LLU; // skip deleter
1850518573 break;
1850618574 }
18507- case 1490LLU: // deleter
18575+ case 1496LLU: // deleter
1850818576 {
1850918577 // throw from ProcCall
18510- if(!stack[base + 18])
18578+ if(!stack[base + 19])
1851118579 {
1851218580 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable [idnr] \n");
18513- label = 1488LLU; // skip, variable already deleted/unscoped
18581+ label = 1494LLU; // skip, variable already deleted/unscoped
1851418582 break;
1851518583 }
1851618584 fprintf(stderr, "in function ProcCall: unrolling stack, variable [idnr] \n");
1851718585 // delete list
18518- label = 1492LLU; // start to repeat
18586+ label = 1498LLU; // start to repeat
1851918587 break;
1852018588 }
18521- case 1492LLU: // repeat from here
18589+ case 1498LLU: // repeat from here
1852218590 {
18523- if(!stack[base + 18])
18591+ if(!stack[base + 19])
1852418592 {
18525- label = 1493LLU; // break loop
18593+ label = 1499LLU; // break loop
1852618594 break;
1852718595 }
1852818596
1852918597 // delete list loop body
1853018598
18531- uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 18])->data - sizeof(uint64_t) * 4);
18599+ uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 19])->data - sizeof(uint64_t) * 4);
1853218600 // call ~idnr from ProcCall
1853318601 newstack[0] = (uint64_t)stack; // backup stack location
1853418602 newstack[1] = 1234567890;
1853518603 newstack[2] = base;
18536- newstack[3] = 1494LLU;
18604+ newstack[3] = 1500LLU;
1853718605 stack = newstack;
1853818606 // set stack-base & callee-address
1853918607 base = 4/*deloffset*/;
@@ -18540,58 +18608,59 @@
1854018608 label = 758LLU; // ~idnr
1854118609 break;
1854218610 }
18543- case 1494LLU: // return from ~idnr to ProcCall
18611+ case 1500LLU: // return from ~idnr to ProcCall
1854418612 {
1854518613 stack = (uint64_t *)stack[0];
1854618614 // releasing toplevel container
18547- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 18])->data - sizeof(uint64_t) * 4));
18615+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 19])->data - sizeof(uint64_t) * 4));
1854818616
1854918617 {
18550- struct listnode *list = (struct listnode *)stack[base + 18];
18551- stack[base + 18] = (uint64_t)list->next;
18618+ struct listnode *list = (struct listnode *)stack[base + 19];
18619+ stack[base + 19] = (uint64_t)list->next;
1855218620 Free(1, sizeof(struct listnode), list);
1855318621 }
18554- label = 1492LLU; // repeat
18622+ label = 1498LLU; // repeat
1855518623 break;
1855618624 }
18557- case 1493LLU: // loop finished
18625+ case 1499LLU: // loop finished
1855818626 {
18559- label = 1488LLU; // continue unrolling stack, delete next variable
18627+ label = 1494LLU; // continue unrolling stack, delete next variable
1856018628 break;
1856118629 }
18562- case 1491LLU: // skipped deleter
18630+ case 1497LLU: // skipped deleter
1856318631 {
18564- stack[base + 18] = 0;
18565- if(/*fndef*/0 != ((uint64_t *)(stack[base + 12]/*calleedef*/))[0])
18632+ stack[base + 19] = 0;
18633+ if(/*fndef*/0 != ((uint64_t *)(stack[base + 13]/*calleedef*/))[0])
1856618634 {
18567- label = 1496LLU; // jump to alternative
18635+ label = 1502LLU; // jump to alternative
1856818636 break;
1856918637 }
1857018638
18571- /*celabel*/stack[base + 19] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][0]/*label*/;
18572- /*cerestypes*/stack[base + 20] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][1]/*restypes*/;
18573- /*ceargtypes*/stack[base + 21] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][2]/*argtypes*/;
18574- /*cemaxcount*/stack[base + 22] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][3]/*maxcount*/;
18575- /*ceid*/stack[base + 23] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][4]/*id*/;
18576- /*cerec*/stack[base + 24] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][5]/*recursive*/;
18577- /*ceerr*/stack[base + 25] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][6]/*fallible*/;
18639+ /*celabel*/stack[base + 20] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][0]/*label*/;
18640+ /*cerestypes*/stack[base + 21] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][1]/*restypes*/;
18641+ /*ceargtypes*/stack[base + 22] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][2]/*argtypes*/;
18642+ /*cemaxcount*/stack[base + 23] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][3]/*maxcount*/;
18643+ /*ceid*/stack[base + 24] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][4]/*id*/;
18644+ /*cerec*/stack[base + 25] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][5]/*recursive*/;
18645+ /*ceerr*/stack[base + 26] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][6]/*fallible*/;
18646+ /*cecanthrow*/stack[base + 27] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][7]/*canthrow*/;
1857818647
1857918648 // case
1858018649 if(!stack[base + 6]/*fnerr*/)
1858118650 {
18582- label = 1497LLU; // jump to alternative
18651+ label = 1503LLU; // jump to alternative
1858318652 break;
1858418653 }
1858518654
1858618655 // consequent
18587- label = 1498LLU; // consequent complete
18656+ label = 1504LLU; // consequent complete
1858818657 break;
1858918658 }
18590- case 1497LLU: // alternative
18659+ case 1503LLU: // alternative
1859118660 {
18592- if(!stack[base + 25]/*ceerr*/)
18661+ if(!stack[base + 26]/*ceerr*/)
1859318662 {
18594- label = 1499LLU; // jump to alternative
18663+ label = 1505LLU; // jump to alternative
1859518664 break;
1859618665 }
1859718666
@@ -18598,855 +18667,935 @@
1859818667 // consequent
1859918668 fprintf(stderr, "%s", "in function ");
1860018669 // call reportid from ProcCall
18601- stack[base + 26LLU] = 1501LLU/*throw to this address*/;
18602- stack[base + 27LLU] = base;
18603- stack[base + 28LLU] = 1502LLU;
18670+ stack[base + 28LLU] = 1507LLU/*throw to this address*/;
18671+ stack[base + 29LLU] = base;
18672+ stack[base + 30LLU] = 1508LLU;
1860418673 // arguments for call to reportid
18605- stack[base + 29LLU] = stack[base + 7]/*fnid*/;
18674+ stack[base + 31LLU] = stack[base + 8]/*fnid*/;
1860618675 // set stack-base & callee-address
18607- base += 29LLU;
18676+ base += 31LLU;
1860818677 label = 18446744073709551586LLU; // reportid
1860918678 break;
1861018679 }
18611- case 1501LLU: // copy-back deleter (reportid to ProcCall)
18680+ case 1507LLU: // copy-back deleter (reportid to ProcCall)
1861218681 {
1861318682 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1861418683 // copy mutable arguments back from call to reportid
18615- label = 1490LLU; // continue to roll stack
18684+ label = 1496LLU; // continue to roll stack
1861618685 break;
1861718686 }
18618- case 1502LLU: // return from reportid to ProcCall
18687+ case 1508LLU: // return from reportid to ProcCall
1861918688 {
1862018689 // copy mutable arguments back from call to reportid
1862118690 fprintf(stderr, "%s", ": partial function ");
1862218691 // call reportid from ProcCall
18623- stack[base + 26LLU] = 1503LLU/*throw to this address*/;
18624- stack[base + 27LLU] = base;
18625- stack[base + 28LLU] = 1504LLU;
18692+ stack[base + 28LLU] = 1509LLU/*throw to this address*/;
18693+ stack[base + 29LLU] = base;
18694+ stack[base + 30LLU] = 1510LLU;
1862618695 // arguments for call to reportid
18627- stack[base + 29LLU] = stack[base + 23]/*ceid*/;
18696+ stack[base + 31LLU] = stack[base + 24]/*ceid*/;
1862818697 // set stack-base & callee-address
18629- base += 29LLU;
18698+ base += 31LLU;
1863018699 label = 18446744073709551586LLU; // reportid
1863118700 break;
1863218701 }
18633- case 1503LLU: // copy-back deleter (reportid to ProcCall)
18702+ case 1509LLU: // copy-back deleter (reportid to ProcCall)
1863418703 {
1863518704 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1863618705 // copy mutable arguments back from call to reportid
18637- label = 1490LLU; // continue to roll stack
18706+ label = 1496LLU; // continue to roll stack
1863818707 break;
1863918708 }
18640- case 1504LLU: // return from reportid to ProcCall
18709+ case 1510LLU: // return from reportid to ProcCall
1864118710 {
1864218711 // copy mutable arguments back from call to reportid
1864318712 fprintf(stderr, "%s", " cannot be called from total function - define caller-function as fallible: prefix return-type with '!'\n");
1864418713 exit(-1);
18645- label = 1500LLU; // consequent complete
18714+ label = 1506LLU; // consequent complete
1864618715 break;
1864718716 }
18648- case 1499LLU: // alternative
18717+ case 1505LLU: // alternative
1864918718 {
18650- label = 1500LLU; // alternative complete
18719+ label = 1506LLU; // alternative complete
1865118720 break;
1865218721 }
18653- case 1500LLU: // completed if-then-else
18722+ case 1506LLU: // completed if-then-else
1865418723 {
18655- label = 1498LLU; // alternative complete
18724+ label = 1504LLU; // alternative complete
1865618725 break;
1865718726 }
18658- case 1498LLU: // completed if-then-else
18727+ case 1504LLU: // completed if-then-else
1865918728 {
18660- label = 1506LLU; // skip deleter
18729+ if(!stack[base + 7]/*fncanthrow*/)
18730+ {
18731+ label = 1511LLU; // jump to alternative
18732+ break;
18733+ }
18734+
18735+ // consequent
18736+ label = 1512LLU; // consequent complete
1866118737 break;
1866218738 }
18663- case 1505LLU: // deleter
18739+ case 1511LLU: // alternative
1866418740 {
18741+ if(!stack[base + 27]/*cecanthrow*/)
18742+ {
18743+ label = 1513LLU; // jump to alternative
18744+ break;
18745+ }
18746+
18747+ // consequent
18748+ fprintf(stderr, "%s", "in function ");
18749+ // call reportid from ProcCall
18750+ stack[base + 28LLU] = 1515LLU/*throw to this address*/;
18751+ stack[base + 29LLU] = base;
18752+ stack[base + 30LLU] = 1516LLU;
18753+ // arguments for call to reportid
18754+ stack[base + 31LLU] = stack[base + 8]/*fnid*/;
18755+ // set stack-base & callee-address
18756+ base += 31LLU;
18757+ label = 18446744073709551586LLU; // reportid
18758+ break;
18759+ }
18760+ case 1515LLU: // copy-back deleter (reportid to ProcCall)
18761+ {
18762+ fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
18763+ // copy mutable arguments back from call to reportid
18764+ label = 1496LLU; // continue to roll stack
18765+ break;
18766+ }
18767+ case 1516LLU: // return from reportid to ProcCall
18768+ {
18769+ // copy mutable arguments back from call to reportid
18770+ fprintf(stderr, "%s", ": call to function ");
18771+ // call reportid from ProcCall
18772+ stack[base + 28LLU] = 1517LLU/*throw to this address*/;
18773+ stack[base + 29LLU] = base;
18774+ stack[base + 30LLU] = 1518LLU;
18775+ // arguments for call to reportid
18776+ stack[base + 31LLU] = stack[base + 24]/*ceid*/;
18777+ // set stack-base & callee-address
18778+ base += 31LLU;
18779+ label = 18446744073709551586LLU; // reportid
18780+ break;
18781+ }
18782+ case 1517LLU: // copy-back deleter (reportid to ProcCall)
18783+ {
18784+ fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
18785+ // copy mutable arguments back from call to reportid
18786+ label = 1496LLU; // continue to roll stack
18787+ break;
18788+ }
18789+ case 1518LLU: // return from reportid to ProcCall
18790+ {
18791+ // copy mutable arguments back from call to reportid
18792+ fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
18793+ exit(-1);
18794+ label = 1514LLU; // consequent complete
18795+ break;
18796+ }
18797+ case 1513LLU: // alternative
18798+ {
18799+ label = 1514LLU; // alternative complete
18800+ break;
18801+ }
18802+ case 1514LLU: // completed if-then-else
18803+ {
18804+ label = 1512LLU; // alternative complete
18805+ break;
18806+ }
18807+ case 1512LLU: // completed if-then-else
18808+ {
18809+ label = 1520LLU; // skip deleter
18810+ break;
18811+ }
18812+ case 1519LLU: // deleter
18813+ {
1866518814 // throw from ProcCall
18666- if(!stack[base + 26])
18815+ if(!stack[base + 28])
1866718816 {
1866818817 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18669- label = 1490LLU; // skip, variable already deleted/unscoped
18818+ label = 1496LLU; // skip, variable already deleted/unscoped
1867018819 break;
1867118820 }
1867218821 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18673- label = 1490LLU; // continue unrolling stack, delete next variable
18822+ label = 1496LLU; // continue unrolling stack, delete next variable
1867418823 break;
1867518824 }
18676- case 1506LLU: // skipped deleter
18825+ case 1520LLU: // skipped deleter
1867718826 {
18678- stack[base + 26] = 0;
18679- stack[base + 26]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 20]/*cerestypes*/)));
18680- label = 1508LLU; // skip deleter
18827+ stack[base + 28] = 0;
18828+ stack[base + 28]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 21]/*cerestypes*/)));
18829+ label = 1522LLU; // skip deleter
1868118830 break;
1868218831 }
18683- case 1507LLU: // deleter
18832+ case 1521LLU: // deleter
1868418833 {
1868518834 // throw from ProcCall
18686- if(!stack[base + 27])
18835+ if(!stack[base + 29])
1868718836 {
1868818837 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18689- label = 1505LLU; // skip, variable already deleted/unscoped
18838+ label = 1519LLU; // skip, variable already deleted/unscoped
1869018839 break;
1869118840 }
1869218841 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18693- label = 1505LLU; // continue unrolling stack, delete next variable
18842+ label = 1519LLU; // continue unrolling stack, delete next variable
1869418843 break;
1869518844 }
18696- case 1508LLU: // skipped deleter
18845+ case 1522LLU: // skipped deleter
1869718846 {
18698- stack[base + 27] = 0;
18699- stack[base + 27]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 21]/*ceargtypes*/)));
18700- if(!stack[base + 19]/*celabel*/)
18847+ stack[base + 29] = 0;
18848+ stack[base + 29]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 22]/*ceargtypes*/)));
18849+ if(!stack[base + 20]/*celabel*/)
1870118850 {
18702- label = 1509LLU; // jump to alternative
18851+ label = 1523LLU; // jump to alternative
1870318852 break;
1870418853 }
1870518854
1870618855 // consequent
18707- label = 1510LLU; // consequent complete
18856+ label = 1524LLU; // consequent complete
1870818857 break;
1870918858 }
18710- case 1509LLU: // alternative
18859+ case 1523LLU: // alternative
1871118860 {
1871218861 fprintf(stderr, "%s", " NULL-label!\n");
1871318862 exit(-1);
18714- label = 1510LLU; // alternative complete
18863+ label = 1524LLU; // alternative complete
1871518864 break;
1871618865 }
18717- case 1510LLU: // completed if-then-else
18866+ case 1524LLU: // completed if-then-else
1871818867 {
18719- label = 1512LLU; // skip deleter
18868+ label = 1526LLU; // skip deleter
1872018869 break;
1872118870 }
18722- case 1511LLU: // deleter
18871+ case 1525LLU: // deleter
1872318872 {
1872418873 // throw from ProcCall
18725- if(!stack[base + 28])
18874+ if(!stack[base + 30])
1872618875 {
1872718876 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18728- label = 1507LLU; // skip, variable already deleted/unscoped
18877+ label = 1521LLU; // skip, variable already deleted/unscoped
1872918878 break;
1873018879 }
1873118880 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18732- label = 1507LLU; // continue unrolling stack, delete next variable
18881+ label = 1521LLU; // continue unrolling stack, delete next variable
1873318882 break;
1873418883 }
18735- case 1512LLU: // skipped deleter
18884+ case 1526LLU: // skipped deleter
1873618885 {
18737- stack[base + 28] = 0;
18738- label = 1514LLU; // skip deleter
18886+ stack[base + 30] = 0;
18887+ label = 1528LLU; // skip deleter
1873918888 break;
1874018889 }
18741- case 1513LLU: // deleter
18890+ case 1527LLU: // deleter
1874218891 {
1874318892 // throw from ProcCall
18744- if(!stack[base + 29])
18893+ if(!stack[base + 31])
1874518894 {
1874618895 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18747- label = 1511LLU; // skip, variable already deleted/unscoped
18896+ label = 1525LLU; // skip, variable already deleted/unscoped
1874818897 break;
1874918898 }
1875018899 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18751- label = 1511LLU; // continue unrolling stack, delete next variable
18900+ label = 1525LLU; // continue unrolling stack, delete next variable
1875218901 break;
1875318902 }
18754- case 1514LLU: // skipped deleter
18903+ case 1528LLU: // skipped deleter
1875518904 {
18756- stack[base + 29] = 0;
18757- label = 1516LLU; // skip deleter
18905+ stack[base + 31] = 0;
18906+ label = 1530LLU; // skip deleter
1875818907 break;
1875918908 }
18760- case 1515LLU: // deleter
18909+ case 1529LLU: // deleter
1876118910 {
1876218911 // throw from ProcCall
18763- if(!stack[base + 30])
18912+ if(!stack[base + 32])
1876418913 {
1876518914 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18766- label = 1513LLU; // skip, variable already deleted/unscoped
18915+ label = 1527LLU; // skip, variable already deleted/unscoped
1876718916 break;
1876818917 }
1876918918 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18770- label = 1513LLU; // continue unrolling stack, delete next variable
18919+ label = 1527LLU; // continue unrolling stack, delete next variable
1877118920 break;
1877218921 }
18773- case 1516LLU: // skipped deleter
18922+ case 1530LLU: // skipped deleter
1877418923 {
18775- stack[base + 30] = 0;
18776- if(!stack[base + 24]/*cerec*/)
18924+ stack[base + 32] = 0;
18925+ if(!stack[base + 25]/*cerec*/)
1877718926 {
18778- label = 1517LLU; // jump to alternative
18927+ label = 1531LLU; // jump to alternative
1877918928 break;
1878018929 }
1878118930
1878218931 // consequent
1878318932 // call add from ProcCall
18784- stack[base + 31LLU] = 1519LLU/*throw to this address*/;
18785- stack[base + 32LLU] = base;
18786- stack[base + 33LLU] = 1520LLU;
18933+ stack[base + 33LLU] = 1533LLU/*throw to this address*/;
18934+ stack[base + 34LLU] = base;
18935+ stack[base + 35LLU] = 1534LLU;
1878718936 // arguments for call to add
18788- stack[base + 35LLU] = 1LLU;
18789- stack[base + 36LLU] = stack[base + 16]/*label*/;
18937+ stack[base + 37LLU] = 1LLU;
18938+ stack[base + 38LLU] = stack[base + 17]/*label*/;
1879018939 // set stack-base & callee-address
18791- base += 34LLU;
18940+ base += 36LLU;
1879218941 label = 18446744073709551605LLU; // add
1879318942 break;
1879418943 }
18795- case 1519LLU: // copy-back deleter (add to ProcCall)
18944+ case 1533LLU: // copy-back deleter (add to ProcCall)
1879618945 {
1879718946 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1879818947 // copy mutable arguments back from call to add
18799- label = 1515LLU; // continue to roll stack
18948+ label = 1529LLU; // continue to roll stack
1880018949 break;
1880118950 }
18802- case 1520LLU: // return from add to ProcCall
18951+ case 1534LLU: // return from add to ProcCall
1880318952 {
1880418953 // copy mutable arguments back from call to add
1880518954 // copy back results provided by call to add
18806- stack[base + 16] = stack[base + 34LLU];
18807- label = 1522LLU; // skip deleter
18955+ stack[base + 17] = stack[base + 36LLU];
18956+ label = 1536LLU; // skip deleter
1880818957 break;
1880918958 }
18810- case 1521LLU: // deleter
18959+ case 1535LLU: // deleter
1881118960 {
1881218961 // throw from ProcCall
18813- if(!stack[base + 31])
18962+ if(!stack[base + 33])
1881418963 {
1881518964 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18816- label = 1515LLU; // skip, variable already deleted/unscoped
18965+ label = 1529LLU; // skip, variable already deleted/unscoped
1881718966 break;
1881818967 }
1881918968 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18820- label = 1515LLU; // continue unrolling stack, delete next variable
18969+ label = 1529LLU; // continue unrolling stack, delete next variable
1882118970 break;
1882218971 }
18823- case 1522LLU: // skipped deleter
18972+ case 1536LLU: // skipped deleter
1882418973 {
18825- stack[base + 31] = stack[base + 16]/*label*/;
18826- label = 1524LLU; // skip deleter
18974+ stack[base + 33] = stack[base + 17]/*label*/;
18975+ label = 1538LLU; // skip deleter
1882718976 break;
1882818977 }
18829- case 1523LLU: // deleter
18978+ case 1537LLU: // deleter
1883018979 {
1883118980 // throw from ProcCall
18832- if(!stack[base + 32])
18981+ if(!stack[base + 34])
1883318982 {
1883418983 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18835- label = 1521LLU; // skip, variable already deleted/unscoped
18984+ label = 1535LLU; // skip, variable already deleted/unscoped
1883618985 break;
1883718986 }
1883818987 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
18839- label = 1521LLU; // continue unrolling stack, delete next variable
18988+ label = 1535LLU; // continue unrolling stack, delete next variable
1884018989 break;
1884118990 }
18842- case 1524LLU: // skipped deleter
18991+ case 1538LLU: // skipped deleter
1884318992 {
18844- stack[base + 32] = 0;
18845- stack[base + 32]/*recsztotal*/ = 0;
18993+ stack[base + 34] = 0;
18994+ stack[base + 34]/*recsztotal*/ = 0;
1884618995 // call add from ProcCall
18847- stack[base + 33LLU] = 1525LLU/*throw to this address*/;
18848- stack[base + 34LLU] = base;
18849- stack[base + 35LLU] = 1526LLU;
18996+ stack[base + 35LLU] = 1539LLU/*throw to this address*/;
18997+ stack[base + 36LLU] = base;
18998+ stack[base + 37LLU] = 1540LLU;
1885018999 // arguments for call to add
18851- stack[base + 37LLU] = 4LLU;
18852- stack[base + 38LLU] = stack[base + 32]/*recsztotal*/;
19000+ stack[base + 39LLU] = 4LLU;
19001+ stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
1885319002 // set stack-base & callee-address
18854- base += 36LLU;
19003+ base += 38LLU;
1885519004 label = 18446744073709551605LLU; // add
1885619005 break;
1885719006 }
18858- case 1525LLU: // copy-back deleter (add to ProcCall)
19007+ case 1539LLU: // copy-back deleter (add to ProcCall)
1885919008 {
1886019009 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1886119010 // copy mutable arguments back from call to add
18862- label = 1523LLU; // continue to roll stack
19011+ label = 1537LLU; // continue to roll stack
1886319012 break;
1886419013 }
18865- case 1526LLU: // return from add to ProcCall
19014+ case 1540LLU: // return from add to ProcCall
1886619015 {
1886719016 // copy mutable arguments back from call to add
1886819017 // copy back results provided by call to add
18869- stack[base + 32] = stack[base + 36LLU];
19018+ stack[base + 34] = stack[base + 38LLU];
1887019019 // call add from ProcCall
18871- stack[base + 33LLU] = 1527LLU/*throw to this address*/;
18872- stack[base + 34LLU] = base;
18873- stack[base + 35LLU] = 1528LLU;
19020+ stack[base + 35LLU] = 1541LLU/*throw to this address*/;
19021+ stack[base + 36LLU] = base;
19022+ stack[base + 37LLU] = 1542LLU;
1887419023 // arguments for call to add
18875- stack[base + 37LLU] = stack[base + 26]/*cerescount*/;
18876- stack[base + 38LLU] = stack[base + 32]/*recsztotal*/;
19024+ stack[base + 39LLU] = stack[base + 28]/*cerescount*/;
19025+ stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
1887719026 // set stack-base & callee-address
18878- base += 36LLU;
19027+ base += 38LLU;
1887919028 label = 18446744073709551605LLU; // add
1888019029 break;
1888119030 }
18882- case 1527LLU: // copy-back deleter (add to ProcCall)
19031+ case 1541LLU: // copy-back deleter (add to ProcCall)
1888319032 {
1888419033 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1888519034 // copy mutable arguments back from call to add
18886- label = 1523LLU; // continue to roll stack
19035+ label = 1537LLU; // continue to roll stack
1888719036 break;
1888819037 }
18889- case 1528LLU: // return from add to ProcCall
19038+ case 1542LLU: // return from add to ProcCall
1889019039 {
1889119040 // copy mutable arguments back from call to add
1889219041 // copy back results provided by call to add
18893- stack[base + 32] = stack[base + 36LLU];
19042+ stack[base + 34] = stack[base + 38LLU];
1889419043 // call add from ProcCall
18895- stack[base + 33LLU] = 1529LLU/*throw to this address*/;
18896- stack[base + 34LLU] = base;
18897- stack[base + 35LLU] = 1530LLU;
19044+ stack[base + 35LLU] = 1543LLU/*throw to this address*/;
19045+ stack[base + 36LLU] = base;
19046+ stack[base + 37LLU] = 1544LLU;
1889819047 // arguments for call to add
18899- stack[base + 37LLU] = stack[base + 27]/*ceargcount*/;
18900- stack[base + 38LLU] = stack[base + 32]/*recsztotal*/;
19048+ stack[base + 39LLU] = stack[base + 29]/*ceargcount*/;
19049+ stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
1890119050 // set stack-base & callee-address
18902- base += 36LLU;
19051+ base += 38LLU;
1890319052 label = 18446744073709551605LLU; // add
1890419053 break;
1890519054 }
18906- case 1529LLU: // copy-back deleter (add to ProcCall)
19055+ case 1543LLU: // copy-back deleter (add to ProcCall)
1890719056 {
1890819057 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1890919058 // copy mutable arguments back from call to add
18910- label = 1523LLU; // continue to roll stack
19059+ label = 1537LLU; // continue to roll stack
1891119060 break;
1891219061 }
18913- case 1530LLU: // return from add to ProcCall
19062+ case 1544LLU: // return from add to ProcCall
1891419063 {
1891519064 // copy mutable arguments back from call to add
1891619065 // copy back results provided by call to add
18917- stack[base + 32] = stack[base + 36LLU];
19066+ stack[base + 34] = stack[base + 38LLU];
1891819067 // call add from ProcCall
18919- stack[base + 33LLU] = 1531LLU/*throw to this address*/;
18920- stack[base + 34LLU] = base;
18921- stack[base + 35LLU] = 1532LLU;
19068+ stack[base + 35LLU] = 1545LLU/*throw to this address*/;
19069+ stack[base + 36LLU] = base;
19070+ stack[base + 37LLU] = 1546LLU;
1892219071 // arguments for call to add
18923- stack[base + 37LLU] = stack[base + 22]/*cemaxcount*/;
18924- stack[base + 38LLU] = stack[base + 32]/*recsztotal*/;
19072+ stack[base + 39LLU] = stack[base + 23]/*cemaxcount*/;
19073+ stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
1892519074 // set stack-base & callee-address
18926- base += 36LLU;
19075+ base += 38LLU;
1892719076 label = 18446744073709551605LLU; // add
1892819077 break;
1892919078 }
18930- case 1531LLU: // copy-back deleter (add to ProcCall)
19079+ case 1545LLU: // copy-back deleter (add to ProcCall)
1893119080 {
1893219081 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1893319082 // copy mutable arguments back from call to add
18934- label = 1523LLU; // continue to roll stack
19083+ label = 1537LLU; // continue to roll stack
1893519084 break;
1893619085 }
18937- case 1532LLU: // return from add to ProcCall
19086+ case 1546LLU: // return from add to ProcCall
1893819087 {
1893919088 // copy mutable arguments back from call to add
1894019089 // copy back results provided by call to add
18941- stack[base + 32] = stack[base + 36LLU];
19090+ stack[base + 34] = stack[base + 38LLU];
1894219091 printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
1894319092 // call printnr from ProcCall
18944- stack[base + 33LLU] = 1533LLU/*throw to this address*/;
18945- stack[base + 34LLU] = base;
18946- stack[base + 35LLU] = 1534LLU;
19093+ stack[base + 35LLU] = 1547LLU/*throw to this address*/;
19094+ stack[base + 36LLU] = base;
19095+ stack[base + 37LLU] = 1548LLU;
1894719096 // arguments for call to printnr
18948- stack[base + 36LLU] = stack[base + 32]/*recsztotal*/;
19097+ stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
1894919098 // set stack-base & callee-address
18950- base += 36LLU;
19099+ base += 38LLU;
1895119100 label = 18446744073709551590LLU; // printnr
1895219101 break;
1895319102 }
18954- case 1533LLU: // copy-back deleter (printnr to ProcCall)
19103+ case 1547LLU: // copy-back deleter (printnr to ProcCall)
1895519104 {
1895619105 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1895719106 // copy mutable arguments back from call to printnr
18958- label = 1523LLU; // continue to roll stack
19107+ label = 1537LLU; // continue to roll stack
1895919108 break;
1896019109 }
18961- case 1534LLU: // return from printnr to ProcCall
19110+ case 1548LLU: // return from printnr to ProcCall
1896219111 {
1896319112 // copy mutable arguments back from call to printnr
1896419113 printf("%s", "LLU + 1, sizeof(uint64_t));");
1896519114 printf("%s", "\n if(!newstack)");
1896619115 // call emitthrow from ProcCall
18967- stack[base + 33LLU] = 1535LLU/*throw to this address*/;
18968- stack[base + 34LLU] = base;
18969- stack[base + 35LLU] = 1536LLU;
19116+ stack[base + 35LLU] = 1549LLU/*throw to this address*/;
19117+ stack[base + 36LLU] = base;
19118+ stack[base + 37LLU] = 1550LLU;
1897019119 // arguments for call to emitthrow
18971- stack[base + 36LLU] = stack[base + 3]/*scope*/;
19120+ stack[base + 38LLU] = stack[base + 3]/*scope*/;
1897219121 // set stack-base & callee-address
18973- base += 36LLU;
18974- label = 1480LLU; // emitthrow
19122+ base += 38LLU;
19123+ label = 1486LLU; // emitthrow
1897519124 break;
1897619125 }
18977- case 1535LLU: // copy-back deleter (emitthrow to ProcCall)
19126+ case 1549LLU: // copy-back deleter (emitthrow to ProcCall)
1897819127 {
1897919128 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitthrow to ProcCall)\n");
1898019129 // copy mutable arguments back from call to emitthrow
18981- label = 1523LLU; // continue to roll stack
19130+ label = 1537LLU; // continue to roll stack
1898219131 break;
1898319132 }
18984- case 1536LLU: // return from emitthrow to ProcCall
19133+ case 1550LLU: // return from emitthrow to ProcCall
1898519134 {
1898619135 // copy mutable arguments back from call to emitthrow
1898719136 printf("%s", "\n newstack[");
1898819137 // call printnr from ProcCall
18989- stack[base + 33LLU] = 1537LLU/*throw to this address*/;
18990- stack[base + 34LLU] = base;
18991- stack[base + 35LLU] = 1538LLU;
19138+ stack[base + 35LLU] = 1551LLU/*throw to this address*/;
19139+ stack[base + 36LLU] = base;
19140+ stack[base + 37LLU] = 1552LLU;
1899219141 // arguments for call to printnr
18993- stack[base + 36LLU] = stack[base + 32]/*recsztotal*/;
19142+ stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
1899419143 // set stack-base & callee-address
18995- base += 36LLU;
19144+ base += 38LLU;
1899619145 label = 18446744073709551590LLU; // printnr
1899719146 break;
1899819147 }
18999- case 1537LLU: // copy-back deleter (printnr to ProcCall)
19148+ case 1551LLU: // copy-back deleter (printnr to ProcCall)
1900019149 {
1900119150 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1900219151 // copy mutable arguments back from call to printnr
19003- label = 1523LLU; // continue to roll stack
19152+ label = 1537LLU; // continue to roll stack
1900419153 break;
1900519154 }
19006- case 1538LLU: // return from printnr to ProcCall
19155+ case 1552LLU: // return from printnr to ProcCall
1900719156 {
1900819157 // copy mutable arguments back from call to printnr
1900919158 printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
1901019159 printf("%s", "\n // call ");
1901119160 // call printid from ProcCall
19012- stack[base + 33LLU] = 1539LLU/*throw to this address*/;
19013- stack[base + 34LLU] = base;
19014- stack[base + 35LLU] = 1540LLU;
19161+ stack[base + 35LLU] = 1553LLU/*throw to this address*/;
19162+ stack[base + 36LLU] = base;
19163+ stack[base + 37LLU] = 1554LLU;
1901519164 // arguments for call to printid
19016- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
19165+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
1901719166 // set stack-base & callee-address
19018- base += 36LLU;
19167+ base += 38LLU;
1901919168 label = 18446744073709551587LLU; // printid
1902019169 break;
1902119170 }
19022- case 1539LLU: // copy-back deleter (printid to ProcCall)
19171+ case 1553LLU: // copy-back deleter (printid to ProcCall)
1902319172 {
1902419173 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
1902519174 // copy mutable arguments back from call to printid
19026- label = 1523LLU; // continue to roll stack
19175+ label = 1537LLU; // continue to roll stack
1902719176 break;
1902819177 }
19029- case 1540LLU: // return from printid to ProcCall
19178+ case 1554LLU: // return from printid to ProcCall
1903019179 {
1903119180 // copy mutable arguments back from call to printid
1903219181 printf("%s", " from ");
1903319182 // call printid from ProcCall
19034- stack[base + 33LLU] = 1541LLU/*throw to this address*/;
19035- stack[base + 34LLU] = base;
19036- stack[base + 35LLU] = 1542LLU;
19183+ stack[base + 35LLU] = 1555LLU/*throw to this address*/;
19184+ stack[base + 36LLU] = base;
19185+ stack[base + 37LLU] = 1556LLU;
1903719186 // arguments for call to printid
19038- stack[base + 36LLU] = stack[base + 7]/*fnid*/;
19187+ stack[base + 38LLU] = stack[base + 8]/*fnid*/;
1903919188 // set stack-base & callee-address
19040- base += 36LLU;
19189+ base += 38LLU;
1904119190 label = 18446744073709551587LLU; // printid
1904219191 break;
1904319192 }
19044- case 1541LLU: // copy-back deleter (printid to ProcCall)
19193+ case 1555LLU: // copy-back deleter (printid to ProcCall)
1904519194 {
1904619195 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
1904719196 // copy mutable arguments back from call to printid
19048- label = 1523LLU; // continue to roll stack
19197+ label = 1537LLU; // continue to roll stack
1904919198 break;
1905019199 }
19051- case 1542LLU: // return from printid to ProcCall
19200+ case 1556LLU: // return from printid to ProcCall
1905219201 {
1905319202 // copy mutable arguments back from call to printid
1905419203 printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
1905519204 printf("%s", "\n newstack[1] = ");
1905619205 // call printnr from ProcCall
19057- stack[base + 33LLU] = 1543LLU/*throw to this address*/;
19058- stack[base + 34LLU] = base;
19059- stack[base + 35LLU] = 1544LLU;
19206+ stack[base + 35LLU] = 1557LLU/*throw to this address*/;
19207+ stack[base + 36LLU] = base;
19208+ stack[base + 37LLU] = 1558LLU;
1906019209 // arguments for call to printnr
19061- stack[base + 36LLU] = stack[base + 31]/*labelfail*/;
19210+ stack[base + 38LLU] = stack[base + 33]/*labelfail*/;
1906219211 // set stack-base & callee-address
19063- base += 36LLU;
19212+ base += 38LLU;
1906419213 label = 18446744073709551590LLU; // printnr
1906519214 break;
1906619215 }
19067- case 1543LLU: // copy-back deleter (printnr to ProcCall)
19216+ case 1557LLU: // copy-back deleter (printnr to ProcCall)
1906819217 {
1906919218 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1907019219 // copy mutable arguments back from call to printnr
19071- label = 1523LLU; // continue to roll stack
19220+ label = 1537LLU; // continue to roll stack
1907219221 break;
1907319222 }
19074- case 1544LLU: // return from printnr to ProcCall
19223+ case 1558LLU: // return from printnr to ProcCall
1907519224 {
1907619225 // copy mutable arguments back from call to printnr
1907719226 printf("%s", "LLU;");
1907819227 printf("%s", "\n newstack[2] = base;");
1907919228 // call add from ProcCall
19080- stack[base + 33LLU] = 1545LLU/*throw to this address*/;
19081- stack[base + 34LLU] = base;
19082- stack[base + 35LLU] = 1546LLU;
19229+ stack[base + 35LLU] = 1559LLU/*throw to this address*/;
19230+ stack[base + 36LLU] = base;
19231+ stack[base + 37LLU] = 1560LLU;
1908319232 // arguments for call to add
19084- stack[base + 37LLU] = 1LLU;
19085- stack[base + 38LLU] = stack[base + 16]/*label*/;
19233+ stack[base + 39LLU] = 1LLU;
19234+ stack[base + 40LLU] = stack[base + 17]/*label*/;
1908619235 // set stack-base & callee-address
19087- base += 36LLU;
19236+ base += 38LLU;
1908819237 label = 18446744073709551605LLU; // add
1908919238 break;
1909019239 }
19091- case 1545LLU: // copy-back deleter (add to ProcCall)
19240+ case 1559LLU: // copy-back deleter (add to ProcCall)
1909219241 {
1909319242 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1909419243 // copy mutable arguments back from call to add
19095- label = 1523LLU; // continue to roll stack
19244+ label = 1537LLU; // continue to roll stack
1909619245 break;
1909719246 }
19098- case 1546LLU: // return from add to ProcCall
19247+ case 1560LLU: // return from add to ProcCall
1909919248 {
1910019249 // copy mutable arguments back from call to add
1910119250 // copy back results provided by call to add
19102- stack[base + 16] = stack[base + 36LLU];
19251+ stack[base + 17] = stack[base + 38LLU];
1910319252 printf("%s", "\n newstack[3] = ");
1910419253 // call printnr from ProcCall
19105- stack[base + 33LLU] = 1547LLU/*throw to this address*/;
19106- stack[base + 34LLU] = base;
19107- stack[base + 35LLU] = 1548LLU;
19254+ stack[base + 35LLU] = 1561LLU/*throw to this address*/;
19255+ stack[base + 36LLU] = base;
19256+ stack[base + 37LLU] = 1562LLU;
1910819257 // arguments for call to printnr
19109- stack[base + 36LLU] = stack[base + 16]/*label*/;
19258+ stack[base + 38LLU] = stack[base + 17]/*label*/;
1911019259 // set stack-base & callee-address
19111- base += 36LLU;
19260+ base += 38LLU;
1911219261 label = 18446744073709551590LLU; // printnr
1911319262 break;
1911419263 }
19115- case 1547LLU: // copy-back deleter (printnr to ProcCall)
19264+ case 1561LLU: // copy-back deleter (printnr to ProcCall)
1911619265 {
1911719266 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1911819267 // copy mutable arguments back from call to printnr
19119- label = 1523LLU; // continue to roll stack
19268+ label = 1537LLU; // continue to roll stack
1912019269 break;
1912119270 }
19122- case 1548LLU: // return from printnr to ProcCall
19271+ case 1562LLU: // return from printnr to ProcCall
1912319272 {
1912419273 // copy mutable arguments back from call to printnr
1912519274 printf("%s", "LLU;");
19126- stack[base + 29]/*n*/ = stack[base + 27]/*ceargcount*/;
19275+ stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
1912719276 printf("%s", "\n // arguments for call to ");
1912819277 // call printid from ProcCall
19129- stack[base + 33LLU] = 1549LLU/*throw to this address*/;
19130- stack[base + 34LLU] = base;
19131- stack[base + 35LLU] = 1550LLU;
19278+ stack[base + 35LLU] = 1563LLU/*throw to this address*/;
19279+ stack[base + 36LLU] = base;
19280+ stack[base + 37LLU] = 1564LLU;
1913219281 // arguments for call to printid
19133- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
19282+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
1913419283 // set stack-base & callee-address
19135- base += 36LLU;
19284+ base += 38LLU;
1913619285 label = 18446744073709551587LLU; // printid
1913719286 break;
1913819287 }
19139- case 1549LLU: // copy-back deleter (printid to ProcCall)
19288+ case 1563LLU: // copy-back deleter (printid to ProcCall)
1914019289 {
1914119290 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
1914219291 // copy mutable arguments back from call to printid
19143- label = 1523LLU; // continue to roll stack
19292+ label = 1537LLU; // continue to roll stack
1914419293 break;
1914519294 }
19146- case 1550LLU: // return from printid to ProcCall
19295+ case 1564LLU: // return from printid to ProcCall
1914719296 {
1914819297 // copy mutable arguments back from call to printid
19149- label = 1552LLU; // skip deleter
19298+ label = 1566LLU; // skip deleter
1915019299 break;
1915119300 }
19152- case 1551LLU: // deleter
19301+ case 1565LLU: // deleter
1915319302 {
1915419303 // throw from ProcCall
19155- if(!stack[base + 33])
19304+ if(!stack[base + 35])
1915619305 {
1915719306 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19158- label = 1523LLU; // skip, variable already deleted/unscoped
19307+ label = 1537LLU; // skip, variable already deleted/unscoped
1915919308 break;
1916019309 }
1916119310 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19162- label = 1523LLU; // continue unrolling stack, delete next variable
19311+ label = 1537LLU; // continue unrolling stack, delete next variable
1916319312 break;
1916419313 }
19165- case 1552LLU: // skipped deleter
19314+ case 1566LLU: // skipped deleter
1916619315 {
19167- stack[base + 33] = 0;
19168- flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 34]);
19169- label = 1553LLU; // start to repeat
19316+ stack[base + 35] = 0;
19317+ flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 36]);
19318+ label = 1567LLU; // start to repeat
1917019319 break;
1917119320 }
19172- case 1553LLU: // repeat from here
19321+ case 1567LLU: // repeat from here
1917319322 {
19174- if(!stack[base + 34])
19323+ if(!stack[base + 36])
1917519324 {
19176- label = 1554LLU; // break loop
19325+ label = 1568LLU; // break loop
1917719326 break;
1917819327 }
1917919328
1918019329 // loop body
19181- stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data);
19182- stack[base + 36]/*previous*/ = stack[base + 34];
19183- stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
19330+ stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->data);
19331+ stack[base + 38]/*previous*/ = stack[base + 36];
19332+ stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
1918419333 // call sub from ProcCall
19185- stack[base + 37LLU] = 1555LLU/*throw to this address*/;
19186- stack[base + 38LLU] = base;
19187- stack[base + 39LLU] = 1556LLU;
19334+ stack[base + 39LLU] = 1569LLU/*throw to this address*/;
19335+ stack[base + 40LLU] = base;
19336+ stack[base + 41LLU] = 1570LLU;
1918819337 // arguments for call to sub
19189- stack[base + 41LLU] = stack[base + 27]/*ceargcount*/;
19190- stack[base + 42LLU] = stack[base + 29]/*n*/;
19338+ stack[base + 43LLU] = stack[base + 29]/*ceargcount*/;
19339+ stack[base + 44LLU] = stack[base + 31]/*n*/;
1919119340 // set stack-base & callee-address
19192- base += 40LLU;
19341+ base += 42LLU;
1919319342 label = 18446744073709551604LLU; // sub
1919419343 break;
1919519344 }
19196- case 1555LLU: // copy-back deleter (sub to ProcCall)
19345+ case 1569LLU: // copy-back deleter (sub to ProcCall)
1919719346 {
1919819347 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
1919919348 // copy mutable arguments back from call to sub
19200- label = 1551LLU; // continue to roll stack
19349+ label = 1565LLU; // continue to roll stack
1920119350 break;
1920219351 }
19203- case 1556LLU: // return from sub to ProcCall
19352+ case 1570LLU: // return from sub to ProcCall
1920419353 {
1920519354 // copy mutable arguments back from call to sub
1920619355 // copy back results provided by call to sub
19207- stack[base + 30] = stack[base + 40LLU];
19356+ stack[base + 32] = stack[base + 42LLU];
1920819357 // call sub from ProcCall
19209- stack[base + 37LLU] = 1557LLU/*throw to this address*/;
19210- stack[base + 38LLU] = base;
19211- stack[base + 39LLU] = 1558LLU;
19358+ stack[base + 39LLU] = 1571LLU/*throw to this address*/;
19359+ stack[base + 40LLU] = base;
19360+ stack[base + 41LLU] = 1572LLU;
1921219361 // arguments for call to sub
19213- stack[base + 41LLU] = stack[base + 29]/*n*/;
19214- stack[base + 42LLU] = 1LLU;
19362+ stack[base + 43LLU] = stack[base + 31]/*n*/;
19363+ stack[base + 44LLU] = 1LLU;
1921519364 // set stack-base & callee-address
19216- base += 40LLU;
19365+ base += 42LLU;
1921719366 label = 18446744073709551604LLU; // sub
1921819367 break;
1921919368 }
19220- case 1557LLU: // copy-back deleter (sub to ProcCall)
19369+ case 1571LLU: // copy-back deleter (sub to ProcCall)
1922119370 {
1922219371 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
1922319372 // copy mutable arguments back from call to sub
19224- label = 1551LLU; // continue to roll stack
19373+ label = 1565LLU; // continue to roll stack
1922519374 break;
1922619375 }
19227- case 1558LLU: // return from sub to ProcCall
19376+ case 1572LLU: // return from sub to ProcCall
1922819377 {
1922919378 // copy mutable arguments back from call to sub
1923019379 // copy back results provided by call to sub
19231- stack[base + 29] = stack[base + 40LLU];
19232- if(!stack[base + 30]/*index*/)
19380+ stack[base + 31] = stack[base + 42LLU];
19381+ if(!stack[base + 32]/*index*/)
1923319382 {
19234- label = 1559LLU; // jump to alternative
19383+ label = 1573LLU; // jump to alternative
1923519384 break;
1923619385 }
1923719386
1923819387 // consequent
1923919388 // call matchsym from ProcCall
19240- stack[base + 37LLU] = 1561LLU/*throw to this address*/;
19241- stack[base + 38LLU] = base;
19242- stack[base + 39LLU] = 1562LLU;
19389+ stack[base + 39LLU] = 1575LLU/*throw to this address*/;
19390+ stack[base + 40LLU] = base;
19391+ stack[base + 41LLU] = 1576LLU;
1924319392 // arguments for call to matchsym
19244- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
19245- stack[base + 41LLU] = 44LLU;
19246- stack[base + 42LLU] = stack[base + 13]/*lookahead*/;
19393+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
19394+ stack[base + 43LLU] = 44LLU;
19395+ stack[base + 44LLU] = stack[base + 14]/*lookahead*/;
1924719396 // set stack-base & callee-address
19248- base += 40LLU;
19397+ base += 42LLU;
1924919398 label = 211LLU; // matchsym
1925019399 break;
1925119400 }
19252- case 1561LLU: // copy-back deleter (matchsym to ProcCall)
19401+ case 1575LLU: // copy-back deleter (matchsym to ProcCall)
1925319402 {
1925419403 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
1925519404 // copy mutable arguments back from call to matchsym
19256- stack[base + 13]/*lookahead*/ = stack[base + 42LLU];
19257- label = 1551LLU; // continue to roll stack
19405+ stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
19406+ label = 1565LLU; // continue to roll stack
1925819407 break;
1925919408 }
19260- case 1562LLU: // return from matchsym to ProcCall
19409+ case 1576LLU: // return from matchsym to ProcCall
1926119410 {
1926219411 // copy mutable arguments back from call to matchsym
19263- stack[base + 13]/*lookahead*/ = stack[base + 42LLU];
19264- label = 1560LLU; // consequent complete
19412+ stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
19413+ label = 1574LLU; // consequent complete
1926519414 break;
1926619415 }
19267- case 1559LLU: // alternative
19416+ case 1573LLU: // alternative
1926819417 {
19269- label = 1560LLU; // alternative complete
19418+ label = 1574LLU; // alternative complete
1927019419 break;
1927119420 }
19272- case 1560LLU: // completed if-then-else
19421+ case 1574LLU: // completed if-then-else
1927319422 {
19274- stack[base + 28]/*sum*/ = 0;
19423+ stack[base + 30]/*sum*/ = 0;
1927519424 // call add from ProcCall
19276- stack[base + 37LLU] = 1563LLU/*throw to this address*/;
19277- stack[base + 38LLU] = base;
19278- stack[base + 39LLU] = 1564LLU;
19425+ stack[base + 39LLU] = 1577LLU/*throw to this address*/;
19426+ stack[base + 40LLU] = base;
19427+ stack[base + 41LLU] = 1578LLU;
1927919428 // arguments for call to add
19280- stack[base + 41LLU] = 4LLU;
19281- stack[base + 42LLU] = stack[base + 28]/*sum*/;
19429+ stack[base + 43LLU] = 4LLU;
19430+ stack[base + 44LLU] = stack[base + 30]/*sum*/;
1928219431 // set stack-base & callee-address
19283- base += 40LLU;
19432+ base += 42LLU;
1928419433 label = 18446744073709551605LLU; // add
1928519434 break;
1928619435 }
19287- case 1563LLU: // copy-back deleter (add to ProcCall)
19436+ case 1577LLU: // copy-back deleter (add to ProcCall)
1928819437 {
1928919438 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1929019439 // copy mutable arguments back from call to add
19291- label = 1551LLU; // continue to roll stack
19440+ label = 1565LLU; // continue to roll stack
1929219441 break;
1929319442 }
19294- case 1564LLU: // return from add to ProcCall
19443+ case 1578LLU: // return from add to ProcCall
1929519444 {
1929619445 // copy mutable arguments back from call to add
1929719446 // copy back results provided by call to add
19298- stack[base + 28] = stack[base + 40LLU];
19447+ stack[base + 30] = stack[base + 42LLU];
1929919448 // call add from ProcCall
19300- stack[base + 37LLU] = 1565LLU/*throw to this address*/;
19301- stack[base + 38LLU] = base;
19302- stack[base + 39LLU] = 1566LLU;
19449+ stack[base + 39LLU] = 1579LLU/*throw to this address*/;
19450+ stack[base + 40LLU] = base;
19451+ stack[base + 41LLU] = 1580LLU;
1930319452 // arguments for call to add
19304- stack[base + 41LLU] = stack[base + 26]/*cerescount*/;
19305- stack[base + 42LLU] = stack[base + 28]/*sum*/;
19453+ stack[base + 43LLU] = stack[base + 28]/*cerescount*/;
19454+ stack[base + 44LLU] = stack[base + 30]/*sum*/;
1930619455 // set stack-base & callee-address
19307- base += 40LLU;
19456+ base += 42LLU;
1930819457 label = 18446744073709551605LLU; // add
1930919458 break;
1931019459 }
19311- case 1565LLU: // copy-back deleter (add to ProcCall)
19460+ case 1579LLU: // copy-back deleter (add to ProcCall)
1931219461 {
1931319462 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1931419463 // copy mutable arguments back from call to add
19315- label = 1551LLU; // continue to roll stack
19464+ label = 1565LLU; // continue to roll stack
1931619465 break;
1931719466 }
19318- case 1566LLU: // return from add to ProcCall
19467+ case 1580LLU: // return from add to ProcCall
1931919468 {
1932019469 // copy mutable arguments back from call to add
1932119470 // copy back results provided by call to add
19322- stack[base + 28] = stack[base + 40LLU];
19471+ stack[base + 30] = stack[base + 42LLU];
1932319472 // call add from ProcCall
19324- stack[base + 37LLU] = 1567LLU/*throw to this address*/;
19325- stack[base + 38LLU] = base;
19326- stack[base + 39LLU] = 1568LLU;
19473+ stack[base + 39LLU] = 1581LLU/*throw to this address*/;
19474+ stack[base + 40LLU] = base;
19475+ stack[base + 41LLU] = 1582LLU;
1932719476 // arguments for call to add
19328- stack[base + 41LLU] = stack[base + 30]/*index*/;
19329- stack[base + 42LLU] = stack[base + 28]/*sum*/;
19477+ stack[base + 43LLU] = stack[base + 32]/*index*/;
19478+ stack[base + 44LLU] = stack[base + 30]/*sum*/;
1933019479 // set stack-base & callee-address
19331- base += 40LLU;
19480+ base += 42LLU;
1933219481 label = 18446744073709551605LLU; // add
1933319482 break;
1933419483 }
19335- case 1567LLU: // copy-back deleter (add to ProcCall)
19484+ case 1581LLU: // copy-back deleter (add to ProcCall)
1933619485 {
1933719486 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
1933819487 // copy mutable arguments back from call to add
19339- label = 1551LLU; // continue to roll stack
19488+ label = 1565LLU; // continue to roll stack
1934019489 break;
1934119490 }
19342- case 1568LLU: // return from add to ProcCall
19491+ case 1582LLU: // return from add to ProcCall
1934319492 {
1934419493 // copy mutable arguments back from call to add
1934519494 // copy back results provided by call to add
19346- stack[base + 28] = stack[base + 40LLU];
19495+ stack[base + 30] = stack[base + 42LLU];
1934719496 // call ParseToken from ProcCall
19348- stack[base + 37LLU] = 1569LLU/*throw to this address*/;
19349- stack[base + 38LLU] = base;
19350- stack[base + 39LLU] = 1570LLU;
19497+ stack[base + 39LLU] = 1583LLU/*throw to this address*/;
19498+ stack[base + 40LLU] = base;
19499+ stack[base + 41LLU] = 1584LLU;
1935119500 // arguments for call to ParseToken
19352- stack[base + 42LLU] = stack[base + 13]/*lookahead*/;
19501+ stack[base + 44LLU] = stack[base + 14]/*lookahead*/;
1935319502 // set stack-base & callee-address
19354- base += 40LLU;
19503+ base += 42LLU;
1935519504 label = 3LLU; // ParseToken
1935619505 break;
1935719506 }
19358- case 1569LLU: // copy-back deleter (ParseToken to ProcCall)
19507+ case 1583LLU: // copy-back deleter (ParseToken to ProcCall)
1935919508 {
1936019509 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n");
1936119510 // copy mutable arguments back from call to ParseToken
19362- stack[base + 13]/*lookahead*/ = stack[base + 42LLU];
19363- label = 1551LLU; // continue to roll stack
19511+ stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
19512+ label = 1565LLU; // continue to roll stack
1936419513 break;
1936519514 }
19366- case 1570LLU: // return from ParseToken to ProcCall
19515+ case 1584LLU: // return from ParseToken to ProcCall
1936719516 {
1936819517 // copy mutable arguments back from call to ParseToken
19369- stack[base + 13]/*lookahead*/ = stack[base + 42LLU];
19518+ stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
1937019519 // copy back results provided by call to ParseToken
19371- stack[base + 14] = stack[base + 40LLU];
19372- stack[base + 15] = stack[base + 41LLU];
19520+ stack[base + 15] = stack[base + 42LLU];
19521+ stack[base + 16] = stack[base + 43LLU];
1937319522 // call isncs from ProcCall
19374- stack[base + 37LLU] = 1571LLU/*throw to this address*/;
19375- stack[base + 38LLU] = base;
19376- stack[base + 39LLU] = 1572LLU;
19523+ stack[base + 39LLU] = 1585LLU/*throw to this address*/;
19524+ stack[base + 40LLU] = base;
19525+ stack[base + 41LLU] = 1586LLU;
1937719526 // arguments for call to isncs
19378- stack[base + 41LLU] = stack[base + 14]/*variant*/;
19527+ stack[base + 43LLU] = stack[base + 15]/*variant*/;
1937919528 // set stack-base & callee-address
19380- base += 40LLU;
19529+ base += 42LLU;
1938119530 label = 271LLU; // isncs
1938219531 break;
1938319532 }
19384- case 1571LLU: // copy-back deleter (isncs to ProcCall)
19533+ case 1585LLU: // copy-back deleter (isncs to ProcCall)
1938519534 {
1938619535 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n");
1938719536 // copy mutable arguments back from call to isncs
19388- label = 1551LLU; // continue to roll stack
19537+ label = 1565LLU; // continue to roll stack
1938919538 break;
1939019539 }
19391- case 1572LLU: // return from isncs to ProcCall
19540+ case 1586LLU: // return from isncs to ProcCall
1939219541 {
1939319542 // copy mutable arguments back from call to isncs
1939419543 // copy back results provided by call to isncs
19395- stack[base + 17] = stack[base + 40LLU];
19396- if(!stack[base + 17]/*isequal*/)
19544+ stack[base + 18] = stack[base + 42LLU];
19545+ if(!stack[base + 18]/*isequal*/)
1939719546 {
19398- label = 1573LLU; // jump to alternative
19547+ label = 1587LLU; // jump to alternative
1939919548 break;
1940019549 }
1940119550
1940219551 // consequent
19403- if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
19552+ if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0])
1940419553 {
19405- label = 1576LLU; // jump to alternative
19554+ label = 1590LLU; // jump to alternative
1940619555 break;
1940719556 }
1940819557
19409- /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/;
19410- /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/;
19558+ /*typeid*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*param*/))[1][0]/*typeid*/;
19559+ /*mutable*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*param*/))[1][1]/*mutable*/;
1941119560
1941219561 // case
19413- if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
19562+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0])
1941419563 {
19415- label = 1578LLU; // jump to alternative
19564+ label = 1592LLU; // jump to alternative
1941619565 break;
1941719566 }
1941819567
19419- /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/;
19420- /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/;
19568+ /*expected*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][0]/*type*/;
19569+ /*paramname*/stack[base + 42] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][1]/*id*/;
1942119570
1942219571 // case
1942319572 // call mktypename from ProcCall
19424- stack[base + 42LLU] = 1579LLU/*throw to this address*/;
19425- stack[base + 43LLU] = base;
19426- stack[base + 44LLU] = 1580LLU;
19573+ stack[base + 44LLU] = 1593LLU/*throw to this address*/;
19574+ stack[base + 45LLU] = base;
19575+ stack[base + 46LLU] = 1594LLU;
1942719576 // arguments for call to mktypename
19428- stack[base + 46LLU] = 881834713755418624LLU;
19577+ stack[base + 48LLU] = 881834713755418624LLU;
1942919578 // set stack-base & callee-address
19430- base += 45LLU;
19579+ base += 47LLU;
1943119580 label = 299LLU; // mktypename
1943219581 break;
1943319582 }
19434- case 1579LLU: // copy-back deleter (mktypename to ProcCall)
19583+ case 1593LLU: // copy-back deleter (mktypename to ProcCall)
1943519584 {
1943619585 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n");
1943719586 // copy mutable arguments back from call to mktypename
19438- label = 1551LLU; // continue to roll stack
19587+ label = 1565LLU; // continue to roll stack
1943919588 break;
1944019589 }
19441- case 1580LLU: // return from mktypename to ProcCall
19590+ case 1594LLU: // return from mktypename to ProcCall
1944219591 {
1944319592 // copy mutable arguments back from call to mktypename
1944419593 // copy back results provided by call to mktypename
19445- stack[base + 41] = stack[base + 45LLU];
19594+ stack[base + 43] = stack[base + 47LLU];
1944619595 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
1944719596 if(!newstack)
1944819597 {
19449- label = 1551LLU; // throw: begin to unroll stack
19598+ label = 1565LLU; // throw: begin to unroll stack
1945019599 break;
1945119600 }
1945219601
@@ -19453,12 +19602,12 @@
1945319602 newstack[15LLU] = 9876543210LLU; // overflow-marker
1945419603 // call equtype from ProcCall
1945519604 newstack[0] = (uint64_t)stack; // backup stack location
19456- newstack[1] = 1581LLU;
19605+ newstack[1] = 1595LLU;
1945719606 newstack[2] = base;
19458- newstack[3] = 1582LLU;
19607+ newstack[3] = 1596LLU;
1945919608 // arguments for call to equtype
19460- newstack[5LLU] = stack[base + 41]/*type*/;
19461- newstack[6LLU] = stack[base + 39]/*expected*/;
19609+ newstack[5LLU] = stack[base + 43]/*type*/;
19610+ newstack[6LLU] = stack[base + 41]/*expected*/;
1946219611 stack = newstack;
1946319612 // set stack-base & callee-address
1946419613 base = 4/*deloffset*/;
@@ -19465,7 +19614,7 @@
1946519614 label = 335LLU; // equtype
1946619615 break;
1946719616 }
19468- case 1581LLU: // copy-back deleter (equtype to ProcCall)
19617+ case 1595LLU: // copy-back deleter (equtype to ProcCall)
1946919618 {
1947019619 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
1947119620 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -19477,15 +19626,15 @@
1947719626 }
1947819627 Free(15LLU + 1, sizeof(uint64_t), stack);
1947919628 stack = oldstack;
19480- label = 1551LLU; // continue to unroll stack
19629+ label = 1565LLU; // continue to unroll stack
1948119630 break;
1948219631 }
19483- case 1582LLU: // return from equtype to ProcCall
19632+ case 1596LLU: // return from equtype to ProcCall
1948419633 {
1948519634 uint64_t *oldstack = (uint64_t *)stack[0];
1948619635 // copy mutable arguments back from call to equtype
1948719636 // copy back results provided by call to equtype
19488- oldstack[base + 17] = stack[4LLU];
19637+ oldstack[base + 18] = stack[4LLU];
1948919638 if(stack[15LLU] != 9876543210LLU)
1949019639 {
1949119640 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -19493,82 +19642,82 @@
1949319642 }
1949419643 Free(15LLU + 1, sizeof(uint64_t), stack);
1949519644 stack = oldstack;
19496- if(!stack[base + 17]/*isequal*/)
19645+ if(!stack[base + 18]/*isequal*/)
1949719646 {
19498- label = 1583LLU; // jump to alternative
19647+ label = 1597LLU; // jump to alternative
1949919648 break;
1950019649 }
1950119650
1950219651 // consequent
19503- label = 1584LLU; // consequent complete
19652+ label = 1598LLU; // consequent complete
1950419653 break;
1950519654 }
19506- case 1583LLU: // alternative
19655+ case 1597LLU: // alternative
1950719656 {
1950819657 fprintf(stderr, "%s", "in function ");
1950919658 // call reportid from ProcCall
19510- stack[base + 42LLU] = 1585LLU/*throw to this address*/;
19511- stack[base + 43LLU] = base;
19512- stack[base + 44LLU] = 1586LLU;
19659+ stack[base + 44LLU] = 1599LLU/*throw to this address*/;
19660+ stack[base + 45LLU] = base;
19661+ stack[base + 46LLU] = 1600LLU;
1951319662 // arguments for call to reportid
19514- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
19663+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
1951519664 // set stack-base & callee-address
19516- base += 45LLU;
19665+ base += 47LLU;
1951719666 label = 18446744073709551586LLU; // reportid
1951819667 break;
1951919668 }
19520- case 1585LLU: // copy-back deleter (reportid to ProcCall)
19669+ case 1599LLU: // copy-back deleter (reportid to ProcCall)
1952119670 {
1952219671 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1952319672 // copy mutable arguments back from call to reportid
19524- label = 1551LLU; // continue to roll stack
19673+ label = 1565LLU; // continue to roll stack
1952519674 break;
1952619675 }
19527- case 1586LLU: // return from reportid to ProcCall
19676+ case 1600LLU: // return from reportid to ProcCall
1952819677 {
1952919678 // copy mutable arguments back from call to reportid
1953019679 fprintf(stderr, "%s", " call to ");
1953119680 // call reportid from ProcCall
19532- stack[base + 42LLU] = 1587LLU/*throw to this address*/;
19533- stack[base + 43LLU] = base;
19534- stack[base + 44LLU] = 1588LLU;
19681+ stack[base + 44LLU] = 1601LLU/*throw to this address*/;
19682+ stack[base + 45LLU] = base;
19683+ stack[base + 46LLU] = 1602LLU;
1953519684 // arguments for call to reportid
19536- stack[base + 45LLU] = stack[base + 23]/*ceid*/;
19685+ stack[base + 47LLU] = stack[base + 24]/*ceid*/;
1953719686 // set stack-base & callee-address
19538- base += 45LLU;
19687+ base += 47LLU;
1953919688 label = 18446744073709551586LLU; // reportid
1954019689 break;
1954119690 }
19542- case 1587LLU: // copy-back deleter (reportid to ProcCall)
19691+ case 1601LLU: // copy-back deleter (reportid to ProcCall)
1954319692 {
1954419693 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1954519694 // copy mutable arguments back from call to reportid
19546- label = 1551LLU; // continue to roll stack
19695+ label = 1565LLU; // continue to roll stack
1954719696 break;
1954819697 }
19549- case 1588LLU: // return from reportid to ProcCall
19698+ case 1602LLU: // return from reportid to ProcCall
1955019699 {
1955119700 // copy mutable arguments back from call to reportid
1955219701 fprintf(stderr, "%s", " at position ");
1955319702 // call reportnr from ProcCall
19554- stack[base + 42LLU] = 1589LLU/*throw to this address*/;
19555- stack[base + 43LLU] = base;
19556- stack[base + 44LLU] = 1590LLU;
19703+ stack[base + 44LLU] = 1603LLU/*throw to this address*/;
19704+ stack[base + 45LLU] = base;
19705+ stack[base + 46LLU] = 1604LLU;
1955719706 // arguments for call to reportnr
19558- stack[base + 45LLU] = stack[base + 30]/*index*/;
19707+ stack[base + 47LLU] = stack[base + 32]/*index*/;
1955919708 // set stack-base & callee-address
19560- base += 45LLU;
19709+ base += 47LLU;
1956119710 label = 18446744073709551589LLU; // reportnr
1956219711 break;
1956319712 }
19564- case 1589LLU: // copy-back deleter (reportnr to ProcCall)
19713+ case 1603LLU: // copy-back deleter (reportnr to ProcCall)
1956519714 {
1956619715 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
1956719716 // copy mutable arguments back from call to reportnr
19568- label = 1551LLU; // continue to roll stack
19717+ label = 1565LLU; // continue to roll stack
1956919718 break;
1957019719 }
19571- case 1590LLU: // return from reportnr to ProcCall
19720+ case 1604LLU: // return from reportnr to ProcCall
1957219721 {
1957319722 // copy mutable arguments back from call to reportnr
1957419723 fprintf(stderr, "%s", " expected parameter of type ");
@@ -19575,7 +19724,7 @@
1957519724 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
1957619725 if(!newstack)
1957719726 {
19578- label = 1551LLU; // throw: begin to unroll stack
19727+ label = 1565LLU; // throw: begin to unroll stack
1957919728 break;
1958019729 }
1958119730
@@ -19582,11 +19731,11 @@
1958219731 newstack[10LLU] = 9876543210LLU; // overflow-marker
1958319732 // call reporttype from ProcCall
1958419733 newstack[0] = (uint64_t)stack; // backup stack location
19585- newstack[1] = 1591LLU;
19734+ newstack[1] = 1605LLU;
1958619735 newstack[2] = base;
19587- newstack[3] = 1592LLU;
19736+ newstack[3] = 1606LLU;
1958819737 // arguments for call to reporttype
19589- newstack[4LLU] = stack[base + 39]/*expected*/;
19738+ newstack[4LLU] = stack[base + 41]/*expected*/;
1959019739 stack = newstack;
1959119740 // set stack-base & callee-address
1959219741 base = 4/*deloffset*/;
@@ -19593,7 +19742,7 @@
1959319742 label = 313LLU; // reporttype
1959419743 break;
1959519744 }
19596- case 1591LLU: // copy-back deleter (reporttype to ProcCall)
19745+ case 1605LLU: // copy-back deleter (reporttype to ProcCall)
1959719746 {
1959819747 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
1959919748 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -19605,10 +19754,10 @@
1960519754 }
1960619755 Free(10LLU + 1, sizeof(uint64_t), stack);
1960719756 stack = oldstack;
19608- label = 1551LLU; // continue to unroll stack
19757+ label = 1565LLU; // continue to unroll stack
1960919758 break;
1961019759 }
19611- case 1592LLU: // return from reporttype to ProcCall
19760+ case 1606LLU: // return from reporttype to ProcCall
1961219761 {
1961319762 uint64_t *oldstack = (uint64_t *)stack[0];
1961419763 // copy mutable arguments back from call to reporttype
@@ -19622,18 +19771,18 @@
1962219771 fprintf(stderr, "%s", " but found constant-argument of type u64");
1962319772 fprintf(stderr, "%s", "\n");
1962419773 exit(-1);
19625- label = 1584LLU; // alternative complete
19774+ label = 1598LLU; // alternative complete
1962619775 break;
1962719776 }
19628- case 1584LLU: // completed if-then-else
19777+ case 1598LLU: // completed if-then-else
1962919778 {
1963019779
19631- uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
19780+ uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4);
1963219781 // call ~type from ProcCall
1963319782 newstack[0] = (uint64_t)stack; // backup stack location
1963419783 newstack[1] = 1234567890;
1963519784 newstack[2] = base;
19636- newstack[3] = 1593LLU;
19785+ newstack[3] = 1607LLU;
1963719786 stack = newstack;
1963819787 // set stack-base & callee-address
1963919788 base = 4/*deloffset*/;
@@ -19640,27 +19789,27 @@
1964019789 label = 295LLU; // ~type
1964119790 break;
1964219791 }
19643- case 1593LLU: // return from ~type to ProcCall
19792+ case 1607LLU: // return from ~type to ProcCall
1964419793 {
1964519794 stack = (uint64_t *)stack[0];
1964619795 // releasing toplevel container
19647- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4));
19796+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
1964819797
19649- ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
19650- ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
19651- label = 1577LLU; // case complete
19798+ ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
19799+ ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
19800+ label = 1591LLU; // case complete
1965219801 break;
1965319802 }
19654- case 1578LLU: // try next case
19803+ case 1592LLU: // try next case
1965519804 {
1965619805 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1965719806 exit(-1);
1965819807 }
19659- case 1577LLU: // completed switch
19808+ case 1591LLU: // completed switch
1966019809 {
19661- if(!stack[base + 38]/*mutable*/)
19810+ if(!stack[base + 40]/*mutable*/)
1966219811 {
19663- label = 1594LLU; // jump to alternative
19812+ label = 1608LLU; // jump to alternative
1966419813 break;
1966519814 }
1966619815
@@ -19667,363 +19816,363 @@
1966719816 // consequent
1966819817 fprintf(stderr, "%s", "in function ");
1966919818 // call reportid from ProcCall
19670- stack[base + 39LLU] = 1596LLU/*throw to this address*/;
19671- stack[base + 40LLU] = base;
19672- stack[base + 41LLU] = 1597LLU;
19819+ stack[base + 41LLU] = 1610LLU/*throw to this address*/;
19820+ stack[base + 42LLU] = base;
19821+ stack[base + 43LLU] = 1611LLU;
1967319822 // arguments for call to reportid
19674- stack[base + 42LLU] = stack[base + 7]/*fnid*/;
19823+ stack[base + 44LLU] = stack[base + 8]/*fnid*/;
1967519824 // set stack-base & callee-address
19676- base += 42LLU;
19825+ base += 44LLU;
1967719826 label = 18446744073709551586LLU; // reportid
1967819827 break;
1967919828 }
19680- case 1596LLU: // copy-back deleter (reportid to ProcCall)
19829+ case 1610LLU: // copy-back deleter (reportid to ProcCall)
1968119830 {
1968219831 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1968319832 // copy mutable arguments back from call to reportid
19684- label = 1551LLU; // continue to roll stack
19833+ label = 1565LLU; // continue to roll stack
1968519834 break;
1968619835 }
19687- case 1597LLU: // return from reportid to ProcCall
19836+ case 1611LLU: // return from reportid to ProcCall
1968819837 {
1968919838 // copy mutable arguments back from call to reportid
1969019839 fprintf(stderr, "%s", ", calling ");
1969119840 // call reportid from ProcCall
19692- stack[base + 39LLU] = 1598LLU/*throw to this address*/;
19693- stack[base + 40LLU] = base;
19694- stack[base + 41LLU] = 1599LLU;
19841+ stack[base + 41LLU] = 1612LLU/*throw to this address*/;
19842+ stack[base + 42LLU] = base;
19843+ stack[base + 43LLU] = 1613LLU;
1969519844 // arguments for call to reportid
19696- stack[base + 42LLU] = stack[base + 23]/*ceid*/;
19845+ stack[base + 44LLU] = stack[base + 24]/*ceid*/;
1969719846 // set stack-base & callee-address
19698- base += 42LLU;
19847+ base += 44LLU;
1969919848 label = 18446744073709551586LLU; // reportid
1970019849 break;
1970119850 }
19702- case 1598LLU: // copy-back deleter (reportid to ProcCall)
19851+ case 1612LLU: // copy-back deleter (reportid to ProcCall)
1970319852 {
1970419853 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
1970519854 // copy mutable arguments back from call to reportid
19706- label = 1551LLU; // continue to roll stack
19855+ label = 1565LLU; // continue to roll stack
1970719856 break;
1970819857 }
19709- case 1599LLU: // return from reportid to ProcCall
19858+ case 1613LLU: // return from reportid to ProcCall
1971019859 {
1971119860 // copy mutable arguments back from call to reportid
1971219861 fprintf(stderr, "%s", ": ");
1971319862 fprintf(stderr, "%s", "can't use constant argument ");
1971419863 // call printnr from ProcCall
19715- stack[base + 39LLU] = 1600LLU/*throw to this address*/;
19716- stack[base + 40LLU] = base;
19717- stack[base + 41LLU] = 1601LLU;
19864+ stack[base + 41LLU] = 1614LLU/*throw to this address*/;
19865+ stack[base + 42LLU] = base;
19866+ stack[base + 43LLU] = 1615LLU;
1971819867 // arguments for call to printnr
19719- stack[base + 42LLU] = stack[base + 15]/*content*/;
19868+ stack[base + 44LLU] = stack[base + 16]/*content*/;
1972019869 // set stack-base & callee-address
19721- base += 42LLU;
19870+ base += 44LLU;
1972219871 label = 18446744073709551590LLU; // printnr
1972319872 break;
1972419873 }
19725- case 1600LLU: // copy-back deleter (printnr to ProcCall)
19874+ case 1614LLU: // copy-back deleter (printnr to ProcCall)
1972619875 {
1972719876 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1972819877 // copy mutable arguments back from call to printnr
19729- label = 1551LLU; // continue to roll stack
19878+ label = 1565LLU; // continue to roll stack
1973019879 break;
1973119880 }
19732- case 1601LLU: // return from printnr to ProcCall
19881+ case 1615LLU: // return from printnr to ProcCall
1973319882 {
1973419883 // copy mutable arguments back from call to printnr
1973519884 printf("%s", " for mutable parameter ");
1973619885 // call reportti from ProcCall
19737- stack[base + 39LLU] = 1602LLU/*throw to this address*/;
19738- stack[base + 40LLU] = base;
19739- stack[base + 41LLU] = 1603LLU;
19886+ stack[base + 41LLU] = 1616LLU/*throw to this address*/;
19887+ stack[base + 42LLU] = base;
19888+ stack[base + 43LLU] = 1617LLU;
1974019889 // arguments for call to reportti
19741- stack[base + 42LLU] = stack[base + 37]/*typeid*/;
19890+ stack[base + 44LLU] = stack[base + 39]/*typeid*/;
1974219891 // set stack-base & callee-address
19743- base += 42LLU;
19892+ base += 44LLU;
1974419893 label = 360LLU; // reportti
1974519894 break;
1974619895 }
19747- case 1602LLU: // copy-back deleter (reportti to ProcCall)
19896+ case 1616LLU: // copy-back deleter (reportti to ProcCall)
1974819897 {
1974919898 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n");
1975019899 // copy mutable arguments back from call to reportti
19751- label = 1551LLU; // continue to roll stack
19900+ label = 1565LLU; // continue to roll stack
1975219901 break;
1975319902 }
19754- case 1603LLU: // return from reportti to ProcCall
19903+ case 1617LLU: // return from reportti to ProcCall
1975519904 {
1975619905 // copy mutable arguments back from call to reportti
1975719906 fprintf(stderr, "%s", "\n");
1975819907 exit(-1);
19759- label = 1595LLU; // consequent complete
19908+ label = 1609LLU; // consequent complete
1976019909 break;
1976119910 }
19762- case 1594LLU: // alternative
19911+ case 1608LLU: // alternative
1976319912 {
19764- label = 1595LLU; // alternative complete
19913+ label = 1609LLU; // alternative complete
1976519914 break;
1976619915 }
19767- case 1595LLU: // completed if-then-else
19916+ case 1609LLU: // completed if-then-else
1976819917 {
19769- ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
19770- ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
19771- label = 1575LLU; // case complete
19918+ ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
19919+ ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
19920+ label = 1589LLU; // case complete
1977219921 break;
1977319922 }
19774- case 1576LLU: // try next case
19923+ case 1590LLU: // try next case
1977519924 {
1977619925 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1977719926 exit(-1);
1977819927 }
19779- case 1575LLU: // completed switch
19928+ case 1589LLU: // completed switch
1978019929 {
1978119930 printf("%s", "\n newstack[");
1978219931 // call printnr from ProcCall
19783- stack[base + 37LLU] = 1604LLU/*throw to this address*/;
19784- stack[base + 38LLU] = base;
19785- stack[base + 39LLU] = 1605LLU;
19932+ stack[base + 39LLU] = 1618LLU/*throw to this address*/;
19933+ stack[base + 40LLU] = base;
19934+ stack[base + 41LLU] = 1619LLU;
1978619935 // arguments for call to printnr
19787- stack[base + 40LLU] = stack[base + 28]/*sum*/;
19936+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
1978819937 // set stack-base & callee-address
19789- base += 40LLU;
19938+ base += 42LLU;
1979019939 label = 18446744073709551590LLU; // printnr
1979119940 break;
1979219941 }
19793- case 1604LLU: // copy-back deleter (printnr to ProcCall)
19942+ case 1618LLU: // copy-back deleter (printnr to ProcCall)
1979419943 {
1979519944 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1979619945 // copy mutable arguments back from call to printnr
19797- label = 1551LLU; // continue to roll stack
19946+ label = 1565LLU; // continue to roll stack
1979819947 break;
1979919948 }
19800- case 1605LLU: // return from printnr to ProcCall
19949+ case 1619LLU: // return from printnr to ProcCall
1980119950 {
1980219951 // copy mutable arguments back from call to printnr
1980319952 printf("%s", "LLU] = ");
1980419953 // call printnr from ProcCall
19805- stack[base + 37LLU] = 1606LLU/*throw to this address*/;
19806- stack[base + 38LLU] = base;
19807- stack[base + 39LLU] = 1607LLU;
19954+ stack[base + 39LLU] = 1620LLU/*throw to this address*/;
19955+ stack[base + 40LLU] = base;
19956+ stack[base + 41LLU] = 1621LLU;
1980819957 // arguments for call to printnr
19809- stack[base + 40LLU] = stack[base + 15]/*content*/;
19958+ stack[base + 42LLU] = stack[base + 16]/*content*/;
1981019959 // set stack-base & callee-address
19811- base += 40LLU;
19960+ base += 42LLU;
1981219961 label = 18446744073709551590LLU; // printnr
1981319962 break;
1981419963 }
19815- case 1606LLU: // copy-back deleter (printnr to ProcCall)
19964+ case 1620LLU: // copy-back deleter (printnr to ProcCall)
1981619965 {
1981719966 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
1981819967 // copy mutable arguments back from call to printnr
19819- label = 1551LLU; // continue to roll stack
19968+ label = 1565LLU; // continue to roll stack
1982019969 break;
1982119970 }
19822- case 1607LLU: // return from printnr to ProcCall
19971+ case 1621LLU: // return from printnr to ProcCall
1982319972 {
1982419973 // copy mutable arguments back from call to printnr
1982519974 printf("%s", "LLU; // ");
1982619975 // call printid from ProcCall
19827- stack[base + 37LLU] = 1608LLU/*throw to this address*/;
19828- stack[base + 38LLU] = base;
19829- stack[base + 39LLU] = 1609LLU;
19976+ stack[base + 39LLU] = 1622LLU/*throw to this address*/;
19977+ stack[base + 40LLU] = base;
19978+ stack[base + 41LLU] = 1623LLU;
1983019979 // arguments for call to printid
19831- stack[base + 40LLU] = stack[base + 15]/*content*/;
19980+ stack[base + 42LLU] = stack[base + 16]/*content*/;
1983219981 // set stack-base & callee-address
19833- base += 40LLU;
19982+ base += 42LLU;
1983419983 label = 18446744073709551587LLU; // printid
1983519984 break;
1983619985 }
19837- case 1608LLU: // copy-back deleter (printid to ProcCall)
19986+ case 1622LLU: // copy-back deleter (printid to ProcCall)
1983819987 {
1983919988 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
1984019989 // copy mutable arguments back from call to printid
19841- label = 1551LLU; // continue to roll stack
19990+ label = 1565LLU; // continue to roll stack
1984219991 break;
1984319992 }
19844- case 1609LLU: // return from printid to ProcCall
19993+ case 1623LLU: // return from printid to ProcCall
1984519994 {
1984619995 // copy mutable arguments back from call to printid
19847- label = 1574LLU; // consequent complete
19996+ label = 1588LLU; // consequent complete
1984819997 break;
1984919998 }
19850- case 1573LLU: // alternative
19999+ case 1587LLU: // alternative
1985120000 {
1985220001 // call equ from ProcCall
19853- stack[base + 37LLU] = 1610LLU/*throw to this address*/;
19854- stack[base + 38LLU] = base;
19855- stack[base + 39LLU] = 1611LLU;
20002+ stack[base + 39LLU] = 1624LLU/*throw to this address*/;
20003+ stack[base + 40LLU] = base;
20004+ stack[base + 41LLU] = 1625LLU;
1985620005 // arguments for call to equ
19857- stack[base + 41LLU] = stack[base + 14]/*variant*/;
19858- stack[base + 42LLU] = 4LLU;
20006+ stack[base + 43LLU] = stack[base + 15]/*variant*/;
20007+ stack[base + 44LLU] = 4LLU;
1985920008 // set stack-base & callee-address
19860- base += 40LLU;
20009+ base += 42LLU;
1986120010 label = 18446744073709551600LLU; // equ
1986220011 break;
1986320012 }
19864- case 1610LLU: // copy-back deleter (equ to ProcCall)
20013+ case 1624LLU: // copy-back deleter (equ to ProcCall)
1986520014 {
1986620015 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
1986720016 // copy mutable arguments back from call to equ
19868- label = 1551LLU; // continue to roll stack
20017+ label = 1565LLU; // continue to roll stack
1986920018 break;
1987020019 }
19871- case 1611LLU: // return from equ to ProcCall
20020+ case 1625LLU: // return from equ to ProcCall
1987220021 {
1987320022 // copy mutable arguments back from call to equ
1987420023 // copy back results provided by call to equ
19875- stack[base + 17] = stack[base + 40LLU];
19876- if(!stack[base + 17]/*isequal*/)
20024+ stack[base + 18] = stack[base + 42LLU];
20025+ if(!stack[base + 18]/*isequal*/)
1987720026 {
19878- label = 1612LLU; // jump to alternative
20027+ label = 1626LLU; // jump to alternative
1987920028 break;
1988020029 }
1988120030
1988220031 // consequent
19883- if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
20032+ if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0])
1988420033 {
19885- label = 1615LLU; // jump to alternative
20034+ label = 1629LLU; // jump to alternative
1988620035 break;
1988720036 }
1988820037
19889- /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/;
19890- /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/;
20038+ /*typeid*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*param*/))[1][0]/*typeid*/;
20039+ /*mutable*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*param*/))[1][1]/*mutable*/;
1989120040
1989220041 // case
19893- if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
20042+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0])
1989420043 {
19895- label = 1617LLU; // jump to alternative
20044+ label = 1631LLU; // jump to alternative
1989620045 break;
1989720046 }
1989820047
19899- /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/;
19900- /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/;
20048+ /*expected*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][0]/*type*/;
20049+ /*paramname*/stack[base + 42] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][1]/*id*/;
1990120050
1990220051 // case
1990320052 // call equ from ProcCall
19904- stack[base + 41LLU] = 1618LLU/*throw to this address*/;
19905- stack[base + 42LLU] = base;
19906- stack[base + 43LLU] = 1619LLU;
20053+ stack[base + 43LLU] = 1632LLU/*throw to this address*/;
20054+ stack[base + 44LLU] = base;
20055+ stack[base + 45LLU] = 1633LLU;
1990720056 // arguments for call to equ
19908- stack[base + 45LLU] = stack[base + 15]/*content*/;
19909- stack[base + 46LLU] = 621705506259468288LLU;
20057+ stack[base + 47LLU] = stack[base + 16]/*content*/;
20058+ stack[base + 48LLU] = 621705506259468288LLU;
1991020059 // set stack-base & callee-address
19911- base += 44LLU;
20060+ base += 46LLU;
1991220061 label = 18446744073709551600LLU; // equ
1991320062 break;
1991420063 }
19915- case 1618LLU: // copy-back deleter (equ to ProcCall)
20064+ case 1632LLU: // copy-back deleter (equ to ProcCall)
1991620065 {
1991720066 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
1991820067 // copy mutable arguments back from call to equ
19919- label = 1551LLU; // continue to roll stack
20068+ label = 1565LLU; // continue to roll stack
1992020069 break;
1992120070 }
19922- case 1619LLU: // return from equ to ProcCall
20071+ case 1633LLU: // return from equ to ProcCall
1992320072 {
1992420073 // copy mutable arguments back from call to equ
1992520074 // copy back results provided by call to equ
19926- stack[base + 17] = stack[base + 44LLU];
19927- if(!stack[base + 17]/*isequal*/)
20075+ stack[base + 18] = stack[base + 46LLU];
20076+ if(!stack[base + 18]/*isequal*/)
1992820077 {
19929- label = 1620LLU; // jump to alternative
20078+ label = 1634LLU; // jump to alternative
1993020079 break;
1993120080 }
1993220081
1993320082 // consequent
1993420083 // call matchsym from ProcCall
19935- stack[base + 41LLU] = 1622LLU/*throw to this address*/;
19936- stack[base + 42LLU] = base;
19937- stack[base + 43LLU] = 1623LLU;
20084+ stack[base + 43LLU] = 1636LLU/*throw to this address*/;
20085+ stack[base + 44LLU] = base;
20086+ stack[base + 45LLU] = 1637LLU;
1993820087 // arguments for call to matchsym
19939- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
19940- stack[base + 45LLU] = 40LLU;
19941- stack[base + 46LLU] = stack[base + 13]/*lookahead*/;
20088+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
20089+ stack[base + 47LLU] = 40LLU;
20090+ stack[base + 48LLU] = stack[base + 14]/*lookahead*/;
1994220091 // set stack-base & callee-address
19943- base += 44LLU;
20092+ base += 46LLU;
1994420093 label = 211LLU; // matchsym
1994520094 break;
1994620095 }
19947- case 1622LLU: // copy-back deleter (matchsym to ProcCall)
20096+ case 1636LLU: // copy-back deleter (matchsym to ProcCall)
1994820097 {
1994920098 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
1995020099 // copy mutable arguments back from call to matchsym
19951- stack[base + 13]/*lookahead*/ = stack[base + 46LLU];
19952- label = 1551LLU; // continue to roll stack
20100+ stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
20101+ label = 1565LLU; // continue to roll stack
1995320102 break;
1995420103 }
19955- case 1623LLU: // return from matchsym to ProcCall
20104+ case 1637LLU: // return from matchsym to ProcCall
1995620105 {
1995720106 // copy mutable arguments back from call to matchsym
19958- stack[base + 13]/*lookahead*/ = stack[base + 46LLU];
20107+ stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
1995920108 // call matchsym from ProcCall
19960- stack[base + 41LLU] = 1624LLU/*throw to this address*/;
19961- stack[base + 42LLU] = base;
19962- stack[base + 43LLU] = 1625LLU;
20109+ stack[base + 43LLU] = 1638LLU/*throw to this address*/;
20110+ stack[base + 44LLU] = base;
20111+ stack[base + 45LLU] = 1639LLU;
1996320112 // arguments for call to matchsym
19964- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
19965- stack[base + 45LLU] = 41LLU;
19966- stack[base + 46LLU] = stack[base + 13]/*lookahead*/;
20113+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
20114+ stack[base + 47LLU] = 41LLU;
20115+ stack[base + 48LLU] = stack[base + 14]/*lookahead*/;
1996720116 // set stack-base & callee-address
19968- base += 44LLU;
20117+ base += 46LLU;
1996920118 label = 211LLU; // matchsym
1997020119 break;
1997120120 }
19972- case 1624LLU: // copy-back deleter (matchsym to ProcCall)
20121+ case 1638LLU: // copy-back deleter (matchsym to ProcCall)
1997320122 {
1997420123 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
1997520124 // copy mutable arguments back from call to matchsym
19976- stack[base + 13]/*lookahead*/ = stack[base + 46LLU];
19977- label = 1551LLU; // continue to roll stack
20125+ stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
20126+ label = 1565LLU; // continue to roll stack
1997820127 break;
1997920128 }
19980- case 1625LLU: // return from matchsym to ProcCall
20129+ case 1639LLU: // return from matchsym to ProcCall
1998120130 {
1998220131 // copy mutable arguments back from call to matchsym
19983- stack[base + 13]/*lookahead*/ = stack[base + 46LLU];
19984- if(/*typename*/0 != ((uint64_t *)(stack[base + 39]/*expected*/))[0])
20132+ stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
20133+ if(/*typename*/0 != ((uint64_t *)(stack[base + 41]/*expected*/))[0])
1998520134 {
19986- label = 1627LLU; // jump to alternative
20135+ label = 1641LLU; // jump to alternative
1998720136 break;
1998820137 }
1998920138
19990- /*name*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*expected*/))[1][0]/*name*/;
20139+ /*name*/stack[base + 43] = ((uint64_t **)(stack[base + 41]/*expected*/))[1][0]/*name*/;
1999120140
1999220141 // case
1999320142 // call equ from ProcCall
19994- stack[base + 42LLU] = 1628LLU/*throw to this address*/;
19995- stack[base + 43LLU] = base;
19996- stack[base + 44LLU] = 1629LLU;
20143+ stack[base + 44LLU] = 1642LLU/*throw to this address*/;
20144+ stack[base + 45LLU] = base;
20145+ stack[base + 46LLU] = 1643LLU;
1999720146 // arguments for call to equ
19998- stack[base + 46LLU] = stack[base + 41]/*name*/;
19999- stack[base + 47LLU] = 881834713755418624LLU;
20147+ stack[base + 48LLU] = stack[base + 43]/*name*/;
20148+ stack[base + 49LLU] = 881834713755418624LLU;
2000020149 // set stack-base & callee-address
20001- base += 45LLU;
20150+ base += 47LLU;
2000220151 label = 18446744073709551600LLU; // equ
2000320152 break;
2000420153 }
20005- case 1628LLU: // copy-back deleter (equ to ProcCall)
20154+ case 1642LLU: // copy-back deleter (equ to ProcCall)
2000620155 {
2000720156 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
2000820157 // copy mutable arguments back from call to equ
20009- label = 1551LLU; // continue to roll stack
20158+ label = 1565LLU; // continue to roll stack
2001020159 break;
2001120160 }
20012- case 1629LLU: // return from equ to ProcCall
20161+ case 1643LLU: // return from equ to ProcCall
2001320162 {
2001420163 // copy mutable arguments back from call to equ
2001520164 // copy back results provided by call to equ
20016- stack[base + 17] = stack[base + 45LLU];
20017- if(!stack[base + 17]/*isequal*/)
20165+ stack[base + 18] = stack[base + 47LLU];
20166+ if(!stack[base + 18]/*isequal*/)
2001820167 {
20019- label = 1630LLU; // jump to alternative
20168+ label = 1644LLU; // jump to alternative
2002020169 break;
2002120170 }
2002220171
2002320172 // consequent
20024- if(!stack[base + 38]/*mutable*/)
20173+ if(!stack[base + 40]/*mutable*/)
2002520174 {
20026- label = 1632LLU; // jump to alternative
20175+ label = 1646LLU; // jump to alternative
2002720176 break;
2002820177 }
2002920178
@@ -20030,46 +20179,46 @@
2003020179 // consequent
2003120180 fprintf(stderr, "%s", "in function ");
2003220181 // call reportid from ProcCall
20033- stack[base + 42LLU] = 1634LLU/*throw to this address*/;
20034- stack[base + 43LLU] = base;
20035- stack[base + 44LLU] = 1635LLU;
20182+ stack[base + 44LLU] = 1648LLU/*throw to this address*/;
20183+ stack[base + 45LLU] = base;
20184+ stack[base + 46LLU] = 1649LLU;
2003620185 // arguments for call to reportid
20037- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
20186+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2003820187 // set stack-base & callee-address
20039- base += 45LLU;
20188+ base += 47LLU;
2004020189 label = 18446744073709551586LLU; // reportid
2004120190 break;
2004220191 }
20043- case 1634LLU: // copy-back deleter (reportid to ProcCall)
20192+ case 1648LLU: // copy-back deleter (reportid to ProcCall)
2004420193 {
2004520194 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2004620195 // copy mutable arguments back from call to reportid
20047- label = 1551LLU; // continue to roll stack
20196+ label = 1565LLU; // continue to roll stack
2004820197 break;
2004920198 }
20050- case 1635LLU: // return from reportid to ProcCall
20199+ case 1649LLU: // return from reportid to ProcCall
2005120200 {
2005220201 // copy mutable arguments back from call to reportid
2005320202 fprintf(stderr, "%s", ", call to ");
2005420203 // call reportid from ProcCall
20055- stack[base + 42LLU] = 1636LLU/*throw to this address*/;
20056- stack[base + 43LLU] = base;
20057- stack[base + 44LLU] = 1637LLU;
20204+ stack[base + 44LLU] = 1650LLU/*throw to this address*/;
20205+ stack[base + 45LLU] = base;
20206+ stack[base + 46LLU] = 1651LLU;
2005820207 // arguments for call to reportid
20059- stack[base + 45LLU] = stack[base + 23]/*ceid*/;
20208+ stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2006020209 // set stack-base & callee-address
20061- base += 45LLU;
20210+ base += 47LLU;
2006220211 label = 18446744073709551586LLU; // reportid
2006320212 break;
2006420213 }
20065- case 1636LLU: // copy-back deleter (reportid to ProcCall)
20214+ case 1650LLU: // copy-back deleter (reportid to ProcCall)
2006620215 {
2006720216 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2006820217 // copy mutable arguments back from call to reportid
20069- label = 1551LLU; // continue to roll stack
20218+ label = 1565LLU; // continue to roll stack
2007020219 break;
2007120220 }
20072- case 1637LLU: // return from reportid to ProcCall
20221+ case 1651LLU: // return from reportid to ProcCall
2007320222 {
2007420223 // copy mutable arguments back from call to reportid
2007520224 fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
@@ -20076,7 +20225,7 @@
2007620225 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2007720226 if(!newstack)
2007820227 {
20079- label = 1551LLU; // throw: begin to unroll stack
20228+ label = 1565LLU; // throw: begin to unroll stack
2008020229 break;
2008120230 }
2008220231
@@ -20083,11 +20232,11 @@
2008320232 newstack[10LLU] = 9876543210LLU; // overflow-marker
2008420233 // call reporttype from ProcCall
2008520234 newstack[0] = (uint64_t)stack; // backup stack location
20086- newstack[1] = 1638LLU;
20235+ newstack[1] = 1652LLU;
2008720236 newstack[2] = base;
20088- newstack[3] = 1639LLU;
20237+ newstack[3] = 1653LLU;
2008920238 // arguments for call to reporttype
20090- newstack[4LLU] = stack[base + 39]/*expected*/;
20239+ newstack[4LLU] = stack[base + 41]/*expected*/;
2009120240 stack = newstack;
2009220241 // set stack-base & callee-address
2009320242 base = 4/*deloffset*/;
@@ -20094,7 +20243,7 @@
2009420243 label = 313LLU; // reporttype
2009520244 break;
2009620245 }
20097- case 1638LLU: // copy-back deleter (reporttype to ProcCall)
20246+ case 1652LLU: // copy-back deleter (reporttype to ProcCall)
2009820247 {
2009920248 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2010020249 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20106,10 +20255,10 @@
2010620255 }
2010720256 Free(10LLU + 1, sizeof(uint64_t), stack);
2010820257 stack = oldstack;
20109- label = 1551LLU; // continue to unroll stack
20258+ label = 1565LLU; // continue to unroll stack
2011020259 break;
2011120260 }
20112- case 1639LLU: // return from reporttype to ProcCall
20261+ case 1653LLU: // return from reporttype to ProcCall
2011320262 {
2011420263 uint64_t *oldstack = (uint64_t *)stack[0];
2011520264 // copy mutable arguments back from call to reporttype
@@ -20121,131 +20270,131 @@
2012120270 Free(10LLU + 1, sizeof(uint64_t), stack);
2012220271 stack = oldstack;
2012320272 // call reportid from ProcCall
20124- stack[base + 42LLU] = 1640LLU/*throw to this address*/;
20125- stack[base + 43LLU] = base;
20126- stack[base + 44LLU] = 1641LLU;
20273+ stack[base + 44LLU] = 1654LLU/*throw to this address*/;
20274+ stack[base + 45LLU] = base;
20275+ stack[base + 46LLU] = 1655LLU;
2012720276 // arguments for call to reportid
20128- stack[base + 45LLU] = stack[base + 40]/*paramname*/;
20277+ stack[base + 47LLU] = stack[base + 42]/*paramname*/;
2012920278 // set stack-base & callee-address
20130- base += 45LLU;
20279+ base += 47LLU;
2013120280 label = 18446744073709551586LLU; // reportid
2013220281 break;
2013320282 }
20134- case 1640LLU: // copy-back deleter (reportid to ProcCall)
20283+ case 1654LLU: // copy-back deleter (reportid to ProcCall)
2013520284 {
2013620285 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2013720286 // copy mutable arguments back from call to reportid
20138- label = 1551LLU; // continue to roll stack
20287+ label = 1565LLU; // continue to roll stack
2013920288 break;
2014020289 }
20141- case 1641LLU: // return from reportid to ProcCall
20290+ case 1655LLU: // return from reportid to ProcCall
2014220291 {
2014320292 // copy mutable arguments back from call to reportid
2014420293 fprintf(stderr, "%s", "\n");
2014520294 exit(-1);
20146- label = 1633LLU; // consequent complete
20295+ label = 1647LLU; // consequent complete
2014720296 break;
2014820297 }
20149- case 1632LLU: // alternative
20298+ case 1646LLU: // alternative
2015020299 {
20151- stack[base + 33]/*csubstruct*/ = 1;
20300+ stack[base + 35]/*csubstruct*/ = 1;
2015220301 printf("%s", "\n newstack[");
2015320302 // call printnr from ProcCall
20154- stack[base + 42LLU] = 1642LLU/*throw to this address*/;
20155- stack[base + 43LLU] = base;
20156- stack[base + 44LLU] = 1643LLU;
20303+ stack[base + 44LLU] = 1656LLU/*throw to this address*/;
20304+ stack[base + 45LLU] = base;
20305+ stack[base + 46LLU] = 1657LLU;
2015720306 // arguments for call to printnr
20158- stack[base + 45LLU] = stack[base + 28]/*sum*/;
20307+ stack[base + 47LLU] = stack[base + 30]/*sum*/;
2015920308 // set stack-base & callee-address
20160- base += 45LLU;
20309+ base += 47LLU;
2016120310 label = 18446744073709551590LLU; // printnr
2016220311 break;
2016320312 }
20164- case 1642LLU: // copy-back deleter (printnr to ProcCall)
20313+ case 1656LLU: // copy-back deleter (printnr to ProcCall)
2016520314 {
2016620315 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2016720316 // copy mutable arguments back from call to printnr
20168- label = 1551LLU; // continue to roll stack
20317+ label = 1565LLU; // continue to roll stack
2016920318 break;
2017020319 }
20171- case 1643LLU: // return from printnr to ProcCall
20320+ case 1657LLU: // return from printnr to ProcCall
2017220321 {
2017320322 // copy mutable arguments back from call to printnr
2017420323 printf("%s", "LLU] = getchar();");
20175- label = 1633LLU; // alternative complete
20324+ label = 1647LLU; // alternative complete
2017620325 break;
2017720326 }
20178- case 1633LLU: // completed if-then-else
20327+ case 1647LLU: // completed if-then-else
2017920328 {
20180- label = 1631LLU; // consequent complete
20329+ label = 1645LLU; // consequent complete
2018120330 break;
2018220331 }
20183- case 1630LLU: // alternative
20332+ case 1644LLU: // alternative
2018420333 {
2018520334 fprintf(stderr, "%s", "in function ");
2018620335 // call reportid from ProcCall
20187- stack[base + 42LLU] = 1644LLU/*throw to this address*/;
20188- stack[base + 43LLU] = base;
20189- stack[base + 44LLU] = 1645LLU;
20336+ stack[base + 44LLU] = 1658LLU/*throw to this address*/;
20337+ stack[base + 45LLU] = base;
20338+ stack[base + 46LLU] = 1659LLU;
2019020339 // arguments for call to reportid
20191- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
20340+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2019220341 // set stack-base & callee-address
20193- base += 45LLU;
20342+ base += 47LLU;
2019420343 label = 18446744073709551586LLU; // reportid
2019520344 break;
2019620345 }
20197- case 1644LLU: // copy-back deleter (reportid to ProcCall)
20346+ case 1658LLU: // copy-back deleter (reportid to ProcCall)
2019820347 {
2019920348 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2020020349 // copy mutable arguments back from call to reportid
20201- label = 1551LLU; // continue to roll stack
20350+ label = 1565LLU; // continue to roll stack
2020220351 break;
2020320352 }
20204- case 1645LLU: // return from reportid to ProcCall
20353+ case 1659LLU: // return from reportid to ProcCall
2020520354 {
2020620355 // copy mutable arguments back from call to reportid
2020720356 fprintf(stderr, "%s", " recursive call to ");
2020820357 // call reportid from ProcCall
20209- stack[base + 42LLU] = 1646LLU/*throw to this address*/;
20210- stack[base + 43LLU] = base;
20211- stack[base + 44LLU] = 1647LLU;
20358+ stack[base + 44LLU] = 1660LLU/*throw to this address*/;
20359+ stack[base + 45LLU] = base;
20360+ stack[base + 46LLU] = 1661LLU;
2021220361 // arguments for call to reportid
20213- stack[base + 45LLU] = stack[base + 23]/*ceid*/;
20362+ stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2021420363 // set stack-base & callee-address
20215- base += 45LLU;
20364+ base += 47LLU;
2021620365 label = 18446744073709551586LLU; // reportid
2021720366 break;
2021820367 }
20219- case 1646LLU: // copy-back deleter (reportid to ProcCall)
20368+ case 1660LLU: // copy-back deleter (reportid to ProcCall)
2022020369 {
2022120370 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2022220371 // copy mutable arguments back from call to reportid
20223- label = 1551LLU; // continue to roll stack
20372+ label = 1565LLU; // continue to roll stack
2022420373 break;
2022520374 }
20226- case 1647LLU: // return from reportid to ProcCall
20375+ case 1661LLU: // return from reportid to ProcCall
2022720376 {
2022820377 // copy mutable arguments back from call to reportid
2022920378 fprintf(stderr, "%s", " at position ");
2023020379 // call reportnr from ProcCall
20231- stack[base + 42LLU] = 1648LLU/*throw to this address*/;
20232- stack[base + 43LLU] = base;
20233- stack[base + 44LLU] = 1649LLU;
20380+ stack[base + 44LLU] = 1662LLU/*throw to this address*/;
20381+ stack[base + 45LLU] = base;
20382+ stack[base + 46LLU] = 1663LLU;
2023420383 // arguments for call to reportnr
20235- stack[base + 45LLU] = stack[base + 30]/*index*/;
20384+ stack[base + 47LLU] = stack[base + 32]/*index*/;
2023620385 // set stack-base & callee-address
20237- base += 45LLU;
20386+ base += 47LLU;
2023820387 label = 18446744073709551589LLU; // reportnr
2023920388 break;
2024020389 }
20241- case 1648LLU: // copy-back deleter (reportnr to ProcCall)
20390+ case 1662LLU: // copy-back deleter (reportnr to ProcCall)
2024220391 {
2024320392 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2024420393 // copy mutable arguments back from call to reportnr
20245- label = 1551LLU; // continue to roll stack
20394+ label = 1565LLU; // continue to roll stack
2024620395 break;
2024720396 }
20248- case 1649LLU: // return from reportnr to ProcCall
20397+ case 1663LLU: // return from reportnr to ProcCall
2024920398 {
2025020399 // copy mutable arguments back from call to reportnr
2025120400 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -20253,7 +20402,7 @@
2025320402 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2025420403 if(!newstack)
2025520404 {
20256- label = 1551LLU; // throw: begin to unroll stack
20405+ label = 1565LLU; // throw: begin to unroll stack
2025720406 break;
2025820407 }
2025920408
@@ -20260,11 +20409,11 @@
2026020409 newstack[10LLU] = 9876543210LLU; // overflow-marker
2026120410 // call reporttype from ProcCall
2026220411 newstack[0] = (uint64_t)stack; // backup stack location
20263- newstack[1] = 1650LLU;
20412+ newstack[1] = 1664LLU;
2026420413 newstack[2] = base;
20265- newstack[3] = 1651LLU;
20414+ newstack[3] = 1665LLU;
2026620415 // arguments for call to reporttype
20267- newstack[4LLU] = stack[base + 39]/*expected*/;
20416+ newstack[4LLU] = stack[base + 41]/*expected*/;
2026820417 stack = newstack;
2026920418 // set stack-base & callee-address
2027020419 base = 4/*deloffset*/;
@@ -20271,7 +20420,7 @@
2027120420 label = 313LLU; // reporttype
2027220421 break;
2027320422 }
20274- case 1650LLU: // copy-back deleter (reporttype to ProcCall)
20423+ case 1664LLU: // copy-back deleter (reporttype to ProcCall)
2027520424 {
2027620425 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2027720426 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20283,10 +20432,10 @@
2028320432 }
2028420433 Free(10LLU + 1, sizeof(uint64_t), stack);
2028520434 stack = oldstack;
20286- label = 1551LLU; // continue to unroll stack
20435+ label = 1565LLU; // continue to unroll stack
2028720436 break;
2028820437 }
20289- case 1651LLU: // return from reporttype to ProcCall
20438+ case 1665LLU: // return from reporttype to ProcCall
2029020439 {
2029120440 uint64_t *oldstack = (uint64_t *)stack[0];
2029220441 // copy mutable arguments back from call to reporttype
@@ -20299,82 +20448,82 @@
2029920448 stack = oldstack;
2030020449 fprintf(stderr, "%s", "\n");
2030120450 exit(-1);
20302- label = 1631LLU; // alternative complete
20451+ label = 1645LLU; // alternative complete
2030320452 break;
2030420453 }
20305- case 1631LLU: // completed if-then-else
20454+ case 1645LLU: // completed if-then-else
2030620455 {
20307- ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
20308- label = 1626LLU; // case complete
20456+ ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
20457+ label = 1640LLU; // case complete
2030920458 break;
2031020459 }
20311- case 1627LLU: // try next case
20460+ case 1641LLU: // try next case
2031220461 {
2031320462 // default
2031420463 fprintf(stderr, "%s", "in function ");
2031520464 // call reportid from ProcCall
20316- stack[base + 41LLU] = 1652LLU/*throw to this address*/;
20317- stack[base + 42LLU] = base;
20318- stack[base + 43LLU] = 1653LLU;
20465+ stack[base + 43LLU] = 1666LLU/*throw to this address*/;
20466+ stack[base + 44LLU] = base;
20467+ stack[base + 45LLU] = 1667LLU;
2031920468 // arguments for call to reportid
20320- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
20469+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2032120470 // set stack-base & callee-address
20322- base += 44LLU;
20471+ base += 46LLU;
2032320472 label = 18446744073709551586LLU; // reportid
2032420473 break;
2032520474 }
20326- case 1652LLU: // copy-back deleter (reportid to ProcCall)
20475+ case 1666LLU: // copy-back deleter (reportid to ProcCall)
2032720476 {
2032820477 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2032920478 // copy mutable arguments back from call to reportid
20330- label = 1551LLU; // continue to roll stack
20479+ label = 1565LLU; // continue to roll stack
2033120480 break;
2033220481 }
20333- case 1653LLU: // return from reportid to ProcCall
20482+ case 1667LLU: // return from reportid to ProcCall
2033420483 {
2033520484 // copy mutable arguments back from call to reportid
2033620485 fprintf(stderr, "%s", " recursive call to ");
2033720486 // call reportid from ProcCall
20338- stack[base + 41LLU] = 1654LLU/*throw to this address*/;
20339- stack[base + 42LLU] = base;
20340- stack[base + 43LLU] = 1655LLU;
20487+ stack[base + 43LLU] = 1668LLU/*throw to this address*/;
20488+ stack[base + 44LLU] = base;
20489+ stack[base + 45LLU] = 1669LLU;
2034120490 // arguments for call to reportid
20342- stack[base + 44LLU] = stack[base + 23]/*ceid*/;
20491+ stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2034320492 // set stack-base & callee-address
20344- base += 44LLU;
20493+ base += 46LLU;
2034520494 label = 18446744073709551586LLU; // reportid
2034620495 break;
2034720496 }
20348- case 1654LLU: // copy-back deleter (reportid to ProcCall)
20497+ case 1668LLU: // copy-back deleter (reportid to ProcCall)
2034920498 {
2035020499 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2035120500 // copy mutable arguments back from call to reportid
20352- label = 1551LLU; // continue to roll stack
20501+ label = 1565LLU; // continue to roll stack
2035320502 break;
2035420503 }
20355- case 1655LLU: // return from reportid to ProcCall
20504+ case 1669LLU: // return from reportid to ProcCall
2035620505 {
2035720506 // copy mutable arguments back from call to reportid
2035820507 fprintf(stderr, "%s", " at position ");
2035920508 // call reportnr from ProcCall
20360- stack[base + 41LLU] = 1656LLU/*throw to this address*/;
20361- stack[base + 42LLU] = base;
20362- stack[base + 43LLU] = 1657LLU;
20509+ stack[base + 43LLU] = 1670LLU/*throw to this address*/;
20510+ stack[base + 44LLU] = base;
20511+ stack[base + 45LLU] = 1671LLU;
2036320512 // arguments for call to reportnr
20364- stack[base + 44LLU] = stack[base + 30]/*index*/;
20513+ stack[base + 46LLU] = stack[base + 32]/*index*/;
2036520514 // set stack-base & callee-address
20366- base += 44LLU;
20515+ base += 46LLU;
2036720516 label = 18446744073709551589LLU; // reportnr
2036820517 break;
2036920518 }
20370- case 1656LLU: // copy-back deleter (reportnr to ProcCall)
20519+ case 1670LLU: // copy-back deleter (reportnr to ProcCall)
2037120520 {
2037220521 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2037320522 // copy mutable arguments back from call to reportnr
20374- label = 1551LLU; // continue to roll stack
20523+ label = 1565LLU; // continue to roll stack
2037520524 break;
2037620525 }
20377- case 1657LLU: // return from reportnr to ProcCall
20526+ case 1671LLU: // return from reportnr to ProcCall
2037820527 {
2037920528 // copy mutable arguments back from call to reportnr
2038020529 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -20382,7 +20531,7 @@
2038220531 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2038320532 if(!newstack)
2038420533 {
20385- label = 1551LLU; // throw: begin to unroll stack
20534+ label = 1565LLU; // throw: begin to unroll stack
2038620535 break;
2038720536 }
2038820537
@@ -20389,11 +20538,11 @@
2038920538 newstack[10LLU] = 9876543210LLU; // overflow-marker
2039020539 // call reporttype from ProcCall
2039120540 newstack[0] = (uint64_t)stack; // backup stack location
20392- newstack[1] = 1658LLU;
20541+ newstack[1] = 1672LLU;
2039320542 newstack[2] = base;
20394- newstack[3] = 1659LLU;
20543+ newstack[3] = 1673LLU;
2039520544 // arguments for call to reporttype
20396- newstack[4LLU] = stack[base + 39]/*expected*/;
20545+ newstack[4LLU] = stack[base + 41]/*expected*/;
2039720546 stack = newstack;
2039820547 // set stack-base & callee-address
2039920548 base = 4/*deloffset*/;
@@ -20400,7 +20549,7 @@
2040020549 label = 313LLU; // reporttype
2040120550 break;
2040220551 }
20403- case 1658LLU: // copy-back deleter (reporttype to ProcCall)
20552+ case 1672LLU: // copy-back deleter (reporttype to ProcCall)
2040420553 {
2040520554 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2040620555 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20412,10 +20561,10 @@
2041220561 }
2041320562 Free(10LLU + 1, sizeof(uint64_t), stack);
2041420563 stack = oldstack;
20415- label = 1551LLU; // continue to unroll stack
20564+ label = 1565LLU; // continue to unroll stack
2041620565 break;
2041720566 }
20418- case 1659LLU: // return from reporttype to ProcCall
20567+ case 1673LLU: // return from reporttype to ProcCall
2041920568 {
2042020569 uint64_t *oldstack = (uint64_t *)stack[0];
2042120570 // copy mutable arguments back from call to reporttype
@@ -20428,83 +20577,83 @@
2042820577 stack = oldstack;
2042920578 fprintf(stderr, "%s", "\n");
2043020579 exit(-1);
20431- label = 1626LLU; // default complete
20580+ label = 1640LLU; // default complete
2043220581 break;
2043320582 }
20434- case 1626LLU: // completed switch
20583+ case 1640LLU: // completed switch
2043520584 {
20436- label = 1621LLU; // consequent complete
20585+ label = 1635LLU; // consequent complete
2043720586 break;
2043820587 }
20439- case 1620LLU: // alternative
20588+ case 1634LLU: // alternative
2044020589 {
2044120590 // call FindLetNew from ProcCall
20442- stack[base + 42LLU] = 1660LLU/*throw to this address*/;
20443- stack[base + 43LLU] = base;
20444- stack[base + 44LLU] = 1661LLU;
20591+ stack[base + 44LLU] = 1674LLU/*throw to this address*/;
20592+ stack[base + 45LLU] = base;
20593+ stack[base + 46LLU] = 1675LLU;
2044520594 // arguments for call to FindLetNew
20446- stack[base + 46LLU] = stack[base + 7]/*fnid*/;
20447- stack[base + 47LLU] = stack[base + 15]/*content*/;
20448- stack[base + 48LLU] = stack[base + 2]/*scopes*/;
20449- stack[base + 49LLU] = stack[base + 3]/*scope*/;
20595+ stack[base + 48LLU] = stack[base + 8]/*fnid*/;
20596+ stack[base + 49LLU] = stack[base + 16]/*content*/;
20597+ stack[base + 50LLU] = stack[base + 2]/*scopes*/;
20598+ stack[base + 51LLU] = stack[base + 3]/*scope*/;
2045020599 // set stack-base & callee-address
20451- base += 45LLU;
20600+ base += 47LLU;
2045220601 label = 561LLU; // FindLetNew
2045320602 break;
2045420603 }
20455- case 1660LLU: // copy-back deleter (FindLetNew to ProcCall)
20604+ case 1674LLU: // copy-back deleter (FindLetNew to ProcCall)
2045620605 {
2045720606 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (FindLetNew to ProcCall)\n");
2045820607 // copy mutable arguments back from call to FindLetNew
20459- label = 1551LLU; // continue to roll stack
20608+ label = 1565LLU; // continue to roll stack
2046020609 break;
2046120610 }
20462- case 1661LLU: // return from FindLetNew to ProcCall
20611+ case 1675LLU: // return from FindLetNew to ProcCall
2046320612 {
2046420613 // copy mutable arguments back from call to FindLetNew
2046520614 // copy back results provided by call to FindLetNew
20466- stack[base + 41] = stack[base + 45LLU];
20467- if(/*letdef*/0 != ((uint64_t *)(stack[base + 41]/*letdef*/))[0])
20615+ stack[base + 43] = stack[base + 47LLU];
20616+ if(/*letdef*/0 != ((uint64_t *)(stack[base + 43]/*letdef*/))[0])
2046820617 {
20469- label = 1663LLU; // jump to alternative
20618+ label = 1677LLU; // jump to alternative
2047020619 break;
2047120620 }
2047220621
20473- /*type*/stack[base + 42] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][0]/*type*/;
20474- /*ldid*/stack[base + 43] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][1]/*id*/;
20475- /*ldindex*/stack[base + 44] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][2]/*index*/;
20476- /*mutarg*/stack[base + 45] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][3]/*mutable*/;
20477- /*substruct*/stack[base + 46] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][4]/*substruct*/;
20622+ /*type*/stack[base + 44] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][0]/*type*/;
20623+ /*ldid*/stack[base + 45] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][1]/*id*/;
20624+ /*ldindex*/stack[base + 46] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][2]/*index*/;
20625+ /*mutarg*/stack[base + 47] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][3]/*mutable*/;
20626+ /*substruct*/stack[base + 48] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][4]/*substruct*/;
2047820627
2047920628 // case
2048020629 // call or from ProcCall
20481- stack[base + 47LLU] = 1664LLU/*throw to this address*/;
20482- stack[base + 48LLU] = base;
20483- stack[base + 49LLU] = 1665LLU;
20630+ stack[base + 49LLU] = 1678LLU/*throw to this address*/;
20631+ stack[base + 50LLU] = base;
20632+ stack[base + 51LLU] = 1679LLU;
2048420633 // arguments for call to or
20485- stack[base + 51LLU] = stack[base + 33]/*csubstruct*/;
20486- stack[base + 52LLU] = stack[base + 46]/*substruct*/;
20634+ stack[base + 53LLU] = stack[base + 35]/*csubstruct*/;
20635+ stack[base + 54LLU] = stack[base + 48]/*substruct*/;
2048720636 // set stack-base & callee-address
20488- base += 50LLU;
20637+ base += 52LLU;
2048920638 label = 18446744073709551611LLU; // or
2049020639 break;
2049120640 }
20492- case 1664LLU: // copy-back deleter (or to ProcCall)
20641+ case 1678LLU: // copy-back deleter (or to ProcCall)
2049320642 {
2049420643 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (or to ProcCall)\n");
2049520644 // copy mutable arguments back from call to or
20496- label = 1551LLU; // continue to roll stack
20645+ label = 1565LLU; // continue to roll stack
2049720646 break;
2049820647 }
20499- case 1665LLU: // return from or to ProcCall
20648+ case 1679LLU: // return from or to ProcCall
2050020649 {
2050120650 // copy mutable arguments back from call to or
2050220651 // copy back results provided by call to or
20503- stack[base + 33] = stack[base + 50LLU];
20652+ stack[base + 35] = stack[base + 52LLU];
2050420653 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2050520654 if(!newstack)
2050620655 {
20507- label = 1551LLU; // throw: begin to unroll stack
20656+ label = 1565LLU; // throw: begin to unroll stack
2050820657 break;
2050920658 }
2051020659
@@ -20511,12 +20660,12 @@
2051120660 newstack[15LLU] = 9876543210LLU; // overflow-marker
2051220661 // call equtype from ProcCall
2051320662 newstack[0] = (uint64_t)stack; // backup stack location
20514- newstack[1] = 1666LLU;
20663+ newstack[1] = 1680LLU;
2051520664 newstack[2] = base;
20516- newstack[3] = 1667LLU;
20665+ newstack[3] = 1681LLU;
2051720666 // arguments for call to equtype
20518- newstack[5LLU] = stack[base + 42]/*type*/;
20519- newstack[6LLU] = stack[base + 39]/*expected*/;
20667+ newstack[5LLU] = stack[base + 44]/*type*/;
20668+ newstack[6LLU] = stack[base + 41]/*expected*/;
2052020669 stack = newstack;
2052120670 // set stack-base & callee-address
2052220671 base = 4/*deloffset*/;
@@ -20523,7 +20672,7 @@
2052320672 label = 335LLU; // equtype
2052420673 break;
2052520674 }
20526- case 1666LLU: // copy-back deleter (equtype to ProcCall)
20675+ case 1680LLU: // copy-back deleter (equtype to ProcCall)
2052720676 {
2052820677 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2052920678 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20535,15 +20684,15 @@
2053520684 }
2053620685 Free(15LLU + 1, sizeof(uint64_t), stack);
2053720686 stack = oldstack;
20538- label = 1551LLU; // continue to unroll stack
20687+ label = 1565LLU; // continue to unroll stack
2053920688 break;
2054020689 }
20541- case 1667LLU: // return from equtype to ProcCall
20690+ case 1681LLU: // return from equtype to ProcCall
2054220691 {
2054320692 uint64_t *oldstack = (uint64_t *)stack[0];
2054420693 // copy mutable arguments back from call to equtype
2054520694 // copy back results provided by call to equtype
20546- oldstack[base + 17] = stack[4LLU];
20695+ oldstack[base + 18] = stack[4LLU];
2054720696 if(stack[15LLU] != 9876543210LLU)
2054820697 {
2054920698 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -20551,82 +20700,82 @@
2055120700 }
2055220701 Free(15LLU + 1, sizeof(uint64_t), stack);
2055320702 stack = oldstack;
20554- if(!stack[base + 17]/*isequal*/)
20703+ if(!stack[base + 18]/*isequal*/)
2055520704 {
20556- label = 1668LLU; // jump to alternative
20705+ label = 1682LLU; // jump to alternative
2055720706 break;
2055820707 }
2055920708
2056020709 // consequent
20561- label = 1669LLU; // consequent complete
20710+ label = 1683LLU; // consequent complete
2056220711 break;
2056320712 }
20564- case 1668LLU: // alternative
20713+ case 1682LLU: // alternative
2056520714 {
2056620715 fprintf(stderr, "%s", "in function ");
2056720716 // call reportid from ProcCall
20568- stack[base + 47LLU] = 1670LLU/*throw to this address*/;
20569- stack[base + 48LLU] = base;
20570- stack[base + 49LLU] = 1671LLU;
20717+ stack[base + 49LLU] = 1684LLU/*throw to this address*/;
20718+ stack[base + 50LLU] = base;
20719+ stack[base + 51LLU] = 1685LLU;
2057120720 // arguments for call to reportid
20572- stack[base + 50LLU] = stack[base + 7]/*fnid*/;
20721+ stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2057320722 // set stack-base & callee-address
20574- base += 50LLU;
20723+ base += 52LLU;
2057520724 label = 18446744073709551586LLU; // reportid
2057620725 break;
2057720726 }
20578- case 1670LLU: // copy-back deleter (reportid to ProcCall)
20727+ case 1684LLU: // copy-back deleter (reportid to ProcCall)
2057920728 {
2058020729 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2058120730 // copy mutable arguments back from call to reportid
20582- label = 1551LLU; // continue to roll stack
20731+ label = 1565LLU; // continue to roll stack
2058320732 break;
2058420733 }
20585- case 1671LLU: // return from reportid to ProcCall
20734+ case 1685LLU: // return from reportid to ProcCall
2058620735 {
2058720736 // copy mutable arguments back from call to reportid
2058820737 fprintf(stderr, "%s", " call to ");
2058920738 // call reportid from ProcCall
20590- stack[base + 47LLU] = 1672LLU/*throw to this address*/;
20591- stack[base + 48LLU] = base;
20592- stack[base + 49LLU] = 1673LLU;
20739+ stack[base + 49LLU] = 1686LLU/*throw to this address*/;
20740+ stack[base + 50LLU] = base;
20741+ stack[base + 51LLU] = 1687LLU;
2059320742 // arguments for call to reportid
20594- stack[base + 50LLU] = stack[base + 23]/*ceid*/;
20743+ stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2059520744 // set stack-base & callee-address
20596- base += 50LLU;
20745+ base += 52LLU;
2059720746 label = 18446744073709551586LLU; // reportid
2059820747 break;
2059920748 }
20600- case 1672LLU: // copy-back deleter (reportid to ProcCall)
20749+ case 1686LLU: // copy-back deleter (reportid to ProcCall)
2060120750 {
2060220751 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2060320752 // copy mutable arguments back from call to reportid
20604- label = 1551LLU; // continue to roll stack
20753+ label = 1565LLU; // continue to roll stack
2060520754 break;
2060620755 }
20607- case 1673LLU: // return from reportid to ProcCall
20756+ case 1687LLU: // return from reportid to ProcCall
2060820757 {
2060920758 // copy mutable arguments back from call to reportid
2061020759 fprintf(stderr, "%s", " at position ");
2061120760 // call reportnr from ProcCall
20612- stack[base + 47LLU] = 1674LLU/*throw to this address*/;
20613- stack[base + 48LLU] = base;
20614- stack[base + 49LLU] = 1675LLU;
20761+ stack[base + 49LLU] = 1688LLU/*throw to this address*/;
20762+ stack[base + 50LLU] = base;
20763+ stack[base + 51LLU] = 1689LLU;
2061520764 // arguments for call to reportnr
20616- stack[base + 50LLU] = stack[base + 30]/*index*/;
20765+ stack[base + 52LLU] = stack[base + 32]/*index*/;
2061720766 // set stack-base & callee-address
20618- base += 50LLU;
20767+ base += 52LLU;
2061920768 label = 18446744073709551589LLU; // reportnr
2062020769 break;
2062120770 }
20622- case 1674LLU: // copy-back deleter (reportnr to ProcCall)
20771+ case 1688LLU: // copy-back deleter (reportnr to ProcCall)
2062320772 {
2062420773 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2062520774 // copy mutable arguments back from call to reportnr
20626- label = 1551LLU; // continue to roll stack
20775+ label = 1565LLU; // continue to roll stack
2062720776 break;
2062820777 }
20629- case 1675LLU: // return from reportnr to ProcCall
20778+ case 1689LLU: // return from reportnr to ProcCall
2063020779 {
2063120780 // copy mutable arguments back from call to reportnr
2063220781 fprintf(stderr, "%s", " parameter type ");
@@ -20633,7 +20782,7 @@
2063320782 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2063420783 if(!newstack)
2063520784 {
20636- label = 1551LLU; // throw: begin to unroll stack
20785+ label = 1565LLU; // throw: begin to unroll stack
2063720786 break;
2063820787 }
2063920788
@@ -20640,11 +20789,11 @@
2064020789 newstack[10LLU] = 9876543210LLU; // overflow-marker
2064120790 // call reporttype from ProcCall
2064220791 newstack[0] = (uint64_t)stack; // backup stack location
20643- newstack[1] = 1676LLU;
20792+ newstack[1] = 1690LLU;
2064420793 newstack[2] = base;
20645- newstack[3] = 1677LLU;
20794+ newstack[3] = 1691LLU;
2064620795 // arguments for call to reporttype
20647- newstack[4LLU] = stack[base + 39]/*expected*/;
20796+ newstack[4LLU] = stack[base + 41]/*expected*/;
2064820797 stack = newstack;
2064920798 // set stack-base & callee-address
2065020799 base = 4/*deloffset*/;
@@ -20651,7 +20800,7 @@
2065120800 label = 313LLU; // reporttype
2065220801 break;
2065320802 }
20654- case 1676LLU: // copy-back deleter (reporttype to ProcCall)
20803+ case 1690LLU: // copy-back deleter (reporttype to ProcCall)
2065520804 {
2065620805 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2065720806 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20663,10 +20812,10 @@
2066320812 }
2066420813 Free(10LLU + 1, sizeof(uint64_t), stack);
2066520814 stack = oldstack;
20666- label = 1551LLU; // continue to unroll stack
20815+ label = 1565LLU; // continue to unroll stack
2066720816 break;
2066820817 }
20669- case 1677LLU: // return from reporttype to ProcCall
20818+ case 1691LLU: // return from reporttype to ProcCall
2067020819 {
2067120820 uint64_t *oldstack = (uint64_t *)stack[0];
2067220821 // copy mutable arguments back from call to reporttype
@@ -20681,7 +20830,7 @@
2068120830 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2068220831 if(!newstack)
2068320832 {
20684- label = 1551LLU; // throw: begin to unroll stack
20833+ label = 1565LLU; // throw: begin to unroll stack
2068520834 break;
2068620835 }
2068720836
@@ -20688,11 +20837,11 @@
2068820837 newstack[10LLU] = 9876543210LLU; // overflow-marker
2068920838 // call reporttype from ProcCall
2069020839 newstack[0] = (uint64_t)stack; // backup stack location
20691- newstack[1] = 1678LLU;
20840+ newstack[1] = 1692LLU;
2069220841 newstack[2] = base;
20693- newstack[3] = 1679LLU;
20842+ newstack[3] = 1693LLU;
2069420843 // arguments for call to reporttype
20695- newstack[4LLU] = stack[base + 42]/*type*/;
20844+ newstack[4LLU] = stack[base + 44]/*type*/;
2069620845 stack = newstack;
2069720846 // set stack-base & callee-address
2069820847 base = 4/*deloffset*/;
@@ -20699,7 +20848,7 @@
2069920848 label = 313LLU; // reporttype
2070020849 break;
2070120850 }
20702- case 1678LLU: // copy-back deleter (reporttype to ProcCall)
20851+ case 1692LLU: // copy-back deleter (reporttype to ProcCall)
2070320852 {
2070420853 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2070520854 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20711,10 +20860,10 @@
2071120860 }
2071220861 Free(10LLU + 1, sizeof(uint64_t), stack);
2071320862 stack = oldstack;
20714- label = 1551LLU; // continue to unroll stack
20863+ label = 1565LLU; // continue to unroll stack
2071520864 break;
2071620865 }
20717- case 1679LLU: // return from reporttype to ProcCall
20866+ case 1693LLU: // return from reporttype to ProcCall
2071820867 {
2071920868 uint64_t *oldstack = (uint64_t *)stack[0];
2072020869 // copy mutable arguments back from call to reporttype
@@ -20727,52 +20876,52 @@
2072720876 stack = oldstack;
2072820877 fprintf(stderr, "%s", "\n");
2072920878 exit(-1);
20730- label = 1669LLU; // alternative complete
20879+ label = 1683LLU; // alternative complete
2073120880 break;
2073220881 }
20733- case 1669LLU: // completed if-then-else
20882+ case 1683LLU: // completed if-then-else
2073420883 {
20735- if(!stack[base + 38]/*mutable*/)
20884+ if(!stack[base + 40]/*mutable*/)
2073620885 {
20737- label = 1680LLU; // jump to alternative
20886+ label = 1694LLU; // jump to alternative
2073820887 break;
2073920888 }
2074020889
2074120890 // consequent
20742- if(!stack[base + 45]/*mutarg*/)
20891+ if(!stack[base + 47]/*mutarg*/)
2074320892 {
20744- label = 1682LLU; // jump to alternative
20893+ label = 1696LLU; // jump to alternative
2074520894 break;
2074620895 }
2074720896
2074820897 // consequent
2074920898 // call lookidnr from ProcCall
20750- stack[base + 48LLU] = 1684LLU/*throw to this address*/;
20751- stack[base + 49LLU] = base;
20752- stack[base + 50LLU] = 1685LLU;
20899+ stack[base + 50LLU] = 1698LLU/*throw to this address*/;
20900+ stack[base + 51LLU] = base;
20901+ stack[base + 52LLU] = 1699LLU;
2075320902 // arguments for call to lookidnr
20754- stack[base + 52LLU] = stack[base + 18]/*copyback*/;
20755- stack[base + 53LLU] = stack[base + 15]/*content*/;
20903+ stack[base + 54LLU] = stack[base + 19]/*copyback*/;
20904+ stack[base + 55LLU] = stack[base + 16]/*content*/;
2075620905 // set stack-base & callee-address
20757- base += 51LLU;
20906+ base += 53LLU;
2075820907 label = 760LLU; // lookidnr
2075920908 break;
2076020909 }
20761- case 1684LLU: // copy-back deleter (lookidnr to ProcCall)
20910+ case 1698LLU: // copy-back deleter (lookidnr to ProcCall)
2076220911 {
2076320912 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n");
2076420913 // copy mutable arguments back from call to lookidnr
20765- label = 1551LLU; // continue to roll stack
20914+ label = 1565LLU; // continue to roll stack
2076620915 break;
2076720916 }
20768- case 1685LLU: // return from lookidnr to ProcCall
20917+ case 1699LLU: // return from lookidnr to ProcCall
2076920918 {
2077020919 // copy mutable arguments back from call to lookidnr
2077120920 // copy back results provided by call to lookidnr
20772- stack[base + 47] = stack[base + 51LLU];
20773- if(!stack[base + 47]/*found*/)
20921+ stack[base + 49] = stack[base + 53LLU];
20922+ if(!stack[base + 49]/*found*/)
2077420923 {
20775- label = 1686LLU; // jump to alternative
20924+ label = 1700LLU; // jump to alternative
2077620925 break;
2077720926 }
2077820927
@@ -20779,102 +20928,102 @@
2077920928 // consequent
2078020929 fprintf(stderr, "%s", "in function ");
2078120930 // call reportid from ProcCall
20782- stack[base + 48LLU] = 1688LLU/*throw to this address*/;
20783- stack[base + 49LLU] = base;
20784- stack[base + 50LLU] = 1689LLU;
20931+ stack[base + 50LLU] = 1702LLU/*throw to this address*/;
20932+ stack[base + 51LLU] = base;
20933+ stack[base + 52LLU] = 1703LLU;
2078520934 // arguments for call to reportid
20786- stack[base + 51LLU] = stack[base + 7]/*fnid*/;
20935+ stack[base + 53LLU] = stack[base + 8]/*fnid*/;
2078720936 // set stack-base & callee-address
20788- base += 51LLU;
20937+ base += 53LLU;
2078920938 label = 18446744073709551586LLU; // reportid
2079020939 break;
2079120940 }
20792- case 1688LLU: // copy-back deleter (reportid to ProcCall)
20941+ case 1702LLU: // copy-back deleter (reportid to ProcCall)
2079320942 {
2079420943 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2079520944 // copy mutable arguments back from call to reportid
20796- label = 1551LLU; // continue to roll stack
20945+ label = 1565LLU; // continue to roll stack
2079720946 break;
2079820947 }
20799- case 1689LLU: // return from reportid to ProcCall
20948+ case 1703LLU: // return from reportid to ProcCall
2080020949 {
2080120950 // copy mutable arguments back from call to reportid
2080220951 fprintf(stderr, "%s", " call to ");
2080320952 // call reportid from ProcCall
20804- stack[base + 48LLU] = 1690LLU/*throw to this address*/;
20805- stack[base + 49LLU] = base;
20806- stack[base + 50LLU] = 1691LLU;
20953+ stack[base + 50LLU] = 1704LLU/*throw to this address*/;
20954+ stack[base + 51LLU] = base;
20955+ stack[base + 52LLU] = 1705LLU;
2080720956 // arguments for call to reportid
20808- stack[base + 51LLU] = stack[base + 23]/*ceid*/;
20957+ stack[base + 53LLU] = stack[base + 24]/*ceid*/;
2080920958 // set stack-base & callee-address
20810- base += 51LLU;
20959+ base += 53LLU;
2081120960 label = 18446744073709551586LLU; // reportid
2081220961 break;
2081320962 }
20814- case 1690LLU: // copy-back deleter (reportid to ProcCall)
20963+ case 1704LLU: // copy-back deleter (reportid to ProcCall)
2081520964 {
2081620965 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2081720966 // copy mutable arguments back from call to reportid
20818- label = 1551LLU; // continue to roll stack
20967+ label = 1565LLU; // continue to roll stack
2081920968 break;
2082020969 }
20821- case 1691LLU: // return from reportid to ProcCall
20970+ case 1705LLU: // return from reportid to ProcCall
2082220971 {
2082320972 // copy mutable arguments back from call to reportid
2082420973 fprintf(stderr, "%s", " - duplicate mutable argument ");
2082520974 // call reportid from ProcCall
20826- stack[base + 48LLU] = 1692LLU/*throw to this address*/;
20827- stack[base + 49LLU] = base;
20828- stack[base + 50LLU] = 1693LLU;
20975+ stack[base + 50LLU] = 1706LLU/*throw to this address*/;
20976+ stack[base + 51LLU] = base;
20977+ stack[base + 52LLU] = 1707LLU;
2082920978 // arguments for call to reportid
20830- stack[base + 51LLU] = stack[base + 15]/*content*/;
20979+ stack[base + 53LLU] = stack[base + 16]/*content*/;
2083120980 // set stack-base & callee-address
20832- base += 51LLU;
20981+ base += 53LLU;
2083320982 label = 18446744073709551586LLU; // reportid
2083420983 break;
2083520984 }
20836- case 1692LLU: // copy-back deleter (reportid to ProcCall)
20985+ case 1706LLU: // copy-back deleter (reportid to ProcCall)
2083720986 {
2083820987 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2083920988 // copy mutable arguments back from call to reportid
20840- label = 1551LLU; // continue to roll stack
20989+ label = 1565LLU; // continue to roll stack
2084120990 break;
2084220991 }
20843- case 1693LLU: // return from reportid to ProcCall
20992+ case 1707LLU: // return from reportid to ProcCall
2084420993 {
2084520994 // copy mutable arguments back from call to reportid
2084620995 fprintf(stderr, "%s", "\n");
2084720996 exit(-1);
20848- label = 1687LLU; // consequent complete
20997+ label = 1701LLU; // consequent complete
2084920998 break;
2085020999 }
20851- case 1686LLU: // alternative
21000+ case 1700LLU: // alternative
2085221001 {
20853- label = 1687LLU; // alternative complete
21002+ label = 1701LLU; // alternative complete
2085421003 break;
2085521004 }
20856- case 1687LLU: // completed if-then-else
21005+ case 1701LLU: // completed if-then-else
2085721006 {
20858- label = 1695LLU; // skip deleter
21007+ label = 1709LLU; // skip deleter
2085921008 break;
2086021009 }
20861- case 1694LLU: // deleter
21010+ case 1708LLU: // deleter
2086221011 {
2086321012 // throw from ProcCall
20864- if(!stack[base + 47])
21013+ if(!stack[base + 49])
2086521014 {
2086621015 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
20867- label = 1551LLU; // skip, variable already deleted/unscoped
21016+ label = 1565LLU; // skip, variable already deleted/unscoped
2086821017 break;
2086921018 }
2087021019 fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");
2087121020
20872- uint64_t *newstack = (uint64_t *)(stack[base + 47] - sizeof(uint64_t) * 4);
21021+ uint64_t *newstack = (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4);
2087321022 // call ~idnr from ProcCall
2087421023 newstack[0] = (uint64_t)stack; // backup stack location
2087521024 newstack[1] = 1234567890;
2087621025 newstack[2] = base;
20877- newstack[3] = 1696LLU;
21026+ newstack[3] = 1710LLU;
2087821027 stack = newstack;
2087921028 // set stack-base & callee-address
2088021029 base = 4/*deloffset*/;
@@ -20881,28 +21030,28 @@
2088121030 label = 758LLU; // ~idnr
2088221031 break;
2088321032 }
20884- case 1696LLU: // return from ~idnr to ProcCall
21033+ case 1710LLU: // return from ~idnr to ProcCall
2088521034 {
2088621035 stack = (uint64_t *)stack[0];
2088721036 // releasing toplevel container
20888- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 47] - sizeof(uint64_t) * 4));
21037+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4));
2088921038
20890- label = 1551LLU; // continue unrolling stack, delete next variable
21039+ label = 1565LLU; // continue unrolling stack, delete next variable
2089121040 break;
2089221041 }
20893- case 1695LLU: // skipped deleter
21042+ case 1709LLU: // skipped deleter
2089421043 {
2089521044 // construct idnr.idnr
20896- if(!(stack[base + 47] = construct(2)))
21045+ if(!(stack[base + 49] = construct(2)))
2089721046 {
20898- label = 1551LLU; // throw: begin to unroll stack
21047+ label = 1565LLU; // throw: begin to unroll stack
2089921048 break;
2090021049 }
2090121050
2090221051 // consequent
20903- ((uint64_t *)stack[base + 47])[0] = 0;
20904- (((uint64_t **)(stack[base + 47]))[1][0]) = stack[base + 15]/*content*/;
20905- (((uint64_t **)(stack[base + 47]))[1][1]) = stack[base + 28]/*sum*/;
21052+ ((uint64_t *)stack[base + 49])[0] = 0;
21053+ (((uint64_t **)(stack[base + 49]))[1][0]) = stack[base + 16]/*content*/;
21054+ (((uint64_t **)(stack[base + 49]))[1][1]) = stack[base + 30]/*sum*/;
2090621055 {
2090721056 struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
2090821057 if(!list)
@@ -20910,57 +21059,57 @@
2091021059 fprintf(stderr, "in function ProcCall push to [idnr]: OUT OF MEMORY!");
2091121060 exit(-1);
2091221061 }
20913- list->next = (struct listnode *)stack[base + 18]/*copyback*/;
20914- stack[base + 18]/*copyback*/ = (uint64_t)list;
20915- MOVE(&list->data, &stack[base + 47]/*idnr*/);
21062+ list->next = (struct listnode *)stack[base + 19]/*copyback*/;
21063+ stack[base + 19]/*copyback*/ = (uint64_t)list;
21064+ MOVE(&list->data, &stack[base + 49]/*idnr*/);
2091621065 }
20917- label = 1683LLU; // consequent complete
21066+ label = 1697LLU; // consequent complete
2091821067 break;
2091921068 }
20920- case 1682LLU: // alternative
21069+ case 1696LLU: // alternative
2092121070 {
2092221071 fprintf(stderr, "%s", "in function ");
2092321072 // call reportid from ProcCall
20924- stack[base + 47LLU] = 1697LLU/*throw to this address*/;
20925- stack[base + 48LLU] = base;
20926- stack[base + 49LLU] = 1698LLU;
21073+ stack[base + 49LLU] = 1711LLU/*throw to this address*/;
21074+ stack[base + 50LLU] = base;
21075+ stack[base + 51LLU] = 1712LLU;
2092721076 // arguments for call to reportid
20928- stack[base + 50LLU] = stack[base + 7]/*fnid*/;
21077+ stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2092921078 // set stack-base & callee-address
20930- base += 50LLU;
21079+ base += 52LLU;
2093121080 label = 18446744073709551586LLU; // reportid
2093221081 break;
2093321082 }
20934- case 1697LLU: // copy-back deleter (reportid to ProcCall)
21083+ case 1711LLU: // copy-back deleter (reportid to ProcCall)
2093521084 {
2093621085 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2093721086 // copy mutable arguments back from call to reportid
20938- label = 1551LLU; // continue to roll stack
21087+ label = 1565LLU; // continue to roll stack
2093921088 break;
2094021089 }
20941- case 1698LLU: // return from reportid to ProcCall
21090+ case 1712LLU: // return from reportid to ProcCall
2094221091 {
2094321092 // copy mutable arguments back from call to reportid
2094421093 fprintf(stderr, "%s", ", call to ");
2094521094 // call reportid from ProcCall
20946- stack[base + 47LLU] = 1699LLU/*throw to this address*/;
20947- stack[base + 48LLU] = base;
20948- stack[base + 49LLU] = 1700LLU;
21095+ stack[base + 49LLU] = 1713LLU/*throw to this address*/;
21096+ stack[base + 50LLU] = base;
21097+ stack[base + 51LLU] = 1714LLU;
2094921098 // arguments for call to reportid
20950- stack[base + 50LLU] = stack[base + 23]/*ceid*/;
21099+ stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2095121100 // set stack-base & callee-address
20952- base += 50LLU;
21101+ base += 52LLU;
2095321102 label = 18446744073709551586LLU; // reportid
2095421103 break;
2095521104 }
20956- case 1699LLU: // copy-back deleter (reportid to ProcCall)
21105+ case 1713LLU: // copy-back deleter (reportid to ProcCall)
2095721106 {
2095821107 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2095921108 // copy mutable arguments back from call to reportid
20960- label = 1551LLU; // continue to roll stack
21109+ label = 1565LLU; // continue to roll stack
2096121110 break;
2096221111 }
20963- case 1700LLU: // return from reportid to ProcCall
21112+ case 1714LLU: // return from reportid to ProcCall
2096421113 {
2096521114 // copy mutable arguments back from call to reportid
2096621115 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -20967,7 +21116,7 @@
2096721116 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2096821117 if(!newstack)
2096921118 {
20970- label = 1551LLU; // throw: begin to unroll stack
21119+ label = 1565LLU; // throw: begin to unroll stack
2097121120 break;
2097221121 }
2097321122
@@ -20974,11 +21123,11 @@
2097421123 newstack[10LLU] = 9876543210LLU; // overflow-marker
2097521124 // call reporttype from ProcCall
2097621125 newstack[0] = (uint64_t)stack; // backup stack location
20977- newstack[1] = 1701LLU;
21126+ newstack[1] = 1715LLU;
2097821127 newstack[2] = base;
20979- newstack[3] = 1702LLU;
21128+ newstack[3] = 1716LLU;
2098021129 // arguments for call to reporttype
20981- newstack[4LLU] = stack[base + 42]/*type*/;
21130+ newstack[4LLU] = stack[base + 44]/*type*/;
2098221131 stack = newstack;
2098321132 // set stack-base & callee-address
2098421133 base = 4/*deloffset*/;
@@ -20985,7 +21134,7 @@
2098521134 label = 313LLU; // reporttype
2098621135 break;
2098721136 }
20988- case 1701LLU: // copy-back deleter (reporttype to ProcCall)
21137+ case 1715LLU: // copy-back deleter (reporttype to ProcCall)
2098921138 {
2099021139 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2099121140 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -20997,10 +21146,10 @@
2099721146 }
2099821147 Free(10LLU + 1, sizeof(uint64_t), stack);
2099921148 stack = oldstack;
21000- label = 1551LLU; // continue to unroll stack
21149+ label = 1565LLU; // continue to unroll stack
2100121150 break;
2100221151 }
21003- case 1702LLU: // return from reporttype to ProcCall
21152+ case 1716LLU: // return from reporttype to ProcCall
2100421153 {
2100521154 uint64_t *oldstack = (uint64_t *)stack[0];
2100621155 // copy mutable arguments back from call to reporttype
@@ -21013,24 +21162,24 @@
2101321162 stack = oldstack;
2101421163 fprintf(stderr, "%s", " ");
2101521164 // call reportid from ProcCall
21016- stack[base + 47LLU] = 1703LLU/*throw to this address*/;
21017- stack[base + 48LLU] = base;
21018- stack[base + 49LLU] = 1704LLU;
21165+ stack[base + 49LLU] = 1717LLU/*throw to this address*/;
21166+ stack[base + 50LLU] = base;
21167+ stack[base + 51LLU] = 1718LLU;
2101921168 // arguments for call to reportid
21020- stack[base + 50LLU] = stack[base + 15]/*content*/;
21169+ stack[base + 52LLU] = stack[base + 16]/*content*/;
2102121170 // set stack-base & callee-address
21022- base += 50LLU;
21171+ base += 52LLU;
2102321172 label = 18446744073709551586LLU; // reportid
2102421173 break;
2102521174 }
21026- case 1703LLU: // copy-back deleter (reportid to ProcCall)
21175+ case 1717LLU: // copy-back deleter (reportid to ProcCall)
2102721176 {
2102821177 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2102921178 // copy mutable arguments back from call to reportid
21030- label = 1551LLU; // continue to roll stack
21179+ label = 1565LLU; // continue to roll stack
2103121180 break;
2103221181 }
21033- case 1704LLU: // return from reportid to ProcCall
21182+ case 1718LLU: // return from reportid to ProcCall
2103421183 {
2103521184 // copy mutable arguments back from call to reportid
2103621185 fprintf(stderr, "%s", " into mutable parameter ");
@@ -21037,7 +21186,7 @@
2103721186 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2103821187 if(!newstack)
2103921188 {
21040- label = 1551LLU; // throw: begin to unroll stack
21189+ label = 1565LLU; // throw: begin to unroll stack
2104121190 break;
2104221191 }
2104321192
@@ -21044,11 +21193,11 @@
2104421193 newstack[10LLU] = 9876543210LLU; // overflow-marker
2104521194 // call reporttype from ProcCall
2104621195 newstack[0] = (uint64_t)stack; // backup stack location
21047- newstack[1] = 1705LLU;
21196+ newstack[1] = 1719LLU;
2104821197 newstack[2] = base;
21049- newstack[3] = 1706LLU;
21198+ newstack[3] = 1720LLU;
2105021199 // arguments for call to reporttype
21051- newstack[4LLU] = stack[base + 39]/*expected*/;
21200+ newstack[4LLU] = stack[base + 41]/*expected*/;
2105221201 stack = newstack;
2105321202 // set stack-base & callee-address
2105421203 base = 4/*deloffset*/;
@@ -21055,7 +21204,7 @@
2105521204 label = 313LLU; // reporttype
2105621205 break;
2105721206 }
21058- case 1705LLU: // copy-back deleter (reporttype to ProcCall)
21207+ case 1719LLU: // copy-back deleter (reporttype to ProcCall)
2105921208 {
2106021209 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2106121210 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -21067,10 +21216,10 @@
2106721216 }
2106821217 Free(10LLU + 1, sizeof(uint64_t), stack);
2106921218 stack = oldstack;
21070- label = 1551LLU; // continue to unroll stack
21219+ label = 1565LLU; // continue to unroll stack
2107121220 break;
2107221221 }
21073- case 1706LLU: // return from reporttype to ProcCall
21222+ case 1720LLU: // return from reporttype to ProcCall
2107421223 {
2107521224 uint64_t *oldstack = (uint64_t *)stack[0];
2107621225 // copy mutable arguments back from call to reporttype
@@ -21082,113 +21231,113 @@
2108221231 Free(10LLU + 1, sizeof(uint64_t), stack);
2108321232 stack = oldstack;
2108421233 // call reportid from ProcCall
21085- stack[base + 47LLU] = 1707LLU/*throw to this address*/;
21086- stack[base + 48LLU] = base;
21087- stack[base + 49LLU] = 1708LLU;
21234+ stack[base + 49LLU] = 1721LLU/*throw to this address*/;
21235+ stack[base + 50LLU] = base;
21236+ stack[base + 51LLU] = 1722LLU;
2108821237 // arguments for call to reportid
21089- stack[base + 50LLU] = stack[base + 40]/*paramname*/;
21238+ stack[base + 52LLU] = stack[base + 42]/*paramname*/;
2109021239 // set stack-base & callee-address
21091- base += 50LLU;
21240+ base += 52LLU;
2109221241 label = 18446744073709551586LLU; // reportid
2109321242 break;
2109421243 }
21095- case 1707LLU: // copy-back deleter (reportid to ProcCall)
21244+ case 1721LLU: // copy-back deleter (reportid to ProcCall)
2109621245 {
2109721246 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2109821247 // copy mutable arguments back from call to reportid
21099- label = 1551LLU; // continue to roll stack
21248+ label = 1565LLU; // continue to roll stack
2110021249 break;
2110121250 }
21102- case 1708LLU: // return from reportid to ProcCall
21251+ case 1722LLU: // return from reportid to ProcCall
2110321252 {
2110421253 // copy mutable arguments back from call to reportid
2110521254 fprintf(stderr, "%s", "\n");
2110621255 exit(-1);
21107- label = 1683LLU; // alternative complete
21256+ label = 1697LLU; // alternative complete
2110821257 break;
2110921258 }
21110- case 1683LLU: // completed if-then-else
21259+ case 1697LLU: // completed if-then-else
2111121260 {
21112- label = 1681LLU; // consequent complete
21261+ label = 1695LLU; // consequent complete
2111321262 break;
2111421263 }
21115- case 1680LLU: // alternative
21264+ case 1694LLU: // alternative
2111621265 {
21117- label = 1681LLU; // alternative complete
21266+ label = 1695LLU; // alternative complete
2111821267 break;
2111921268 }
21120- case 1681LLU: // completed if-then-else
21269+ case 1695LLU: // completed if-then-else
2112121270 {
21122- ((uint64_t **)(stack[base + 41]))[1][4] = stack[base + 46];
21123- ((uint64_t **)(stack[base + 41]))[1][3] = stack[base + 45];
21124- ((uint64_t **)(stack[base + 41]))[1][2] = stack[base + 44];
21125- ((uint64_t **)(stack[base + 41]))[1][1] = stack[base + 43];
21126- ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 42];
21127- label = 1662LLU; // case complete
21271+ ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
21272+ ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
21273+ ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
21274+ ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
21275+ ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
21276+ label = 1676LLU; // case complete
2112821277 break;
2112921278 }
21130- case 1663LLU: // try next case
21279+ case 1677LLU: // try next case
2113121280 {
2113221281 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2113321282 exit(-1);
2113421283 }
21135- case 1662LLU: // completed switch
21284+ case 1676LLU: // completed switch
2113621285 {
2113721286 printf("%s", "\n newstack[");
2113821287 // call printnr from ProcCall
21139- stack[base + 42LLU] = 1709LLU/*throw to this address*/;
21140- stack[base + 43LLU] = base;
21141- stack[base + 44LLU] = 1710LLU;
21288+ stack[base + 44LLU] = 1723LLU/*throw to this address*/;
21289+ stack[base + 45LLU] = base;
21290+ stack[base + 46LLU] = 1724LLU;
2114221291 // arguments for call to printnr
21143- stack[base + 45LLU] = stack[base + 28]/*sum*/;
21292+ stack[base + 47LLU] = stack[base + 30]/*sum*/;
2114421293 // set stack-base & callee-address
21145- base += 45LLU;
21294+ base += 47LLU;
2114621295 label = 18446744073709551590LLU; // printnr
2114721296 break;
2114821297 }
21149- case 1709LLU: // copy-back deleter (printnr to ProcCall)
21298+ case 1723LLU: // copy-back deleter (printnr to ProcCall)
2115021299 {
2115121300 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2115221301 // copy mutable arguments back from call to printnr
21153- label = 1551LLU; // continue to roll stack
21302+ label = 1565LLU; // continue to roll stack
2115421303 break;
2115521304 }
21156- case 1710LLU: // return from printnr to ProcCall
21305+ case 1724LLU: // return from printnr to ProcCall
2115721306 {
2115821307 // copy mutable arguments back from call to printnr
2115921308 printf("%s", "LLU] = ");
2116021309 // call emitvar from ProcCall
21161- stack[base + 42LLU] = 1711LLU/*throw to this address*/;
21162- stack[base + 43LLU] = base;
21163- stack[base + 44LLU] = 1712LLU;
21310+ stack[base + 44LLU] = 1725LLU/*throw to this address*/;
21311+ stack[base + 45LLU] = base;
21312+ stack[base + 46LLU] = 1726LLU;
2116421313 // arguments for call to emitvar
21165- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
21166- stack[base + 46LLU] = stack[base + 15]/*content*/;
21167- stack[base + 47LLU] = stack[base + 2]/*scopes*/;
21168- stack[base + 48LLU] = stack[base + 3]/*scope*/;
21314+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
21315+ stack[base + 48LLU] = stack[base + 16]/*content*/;
21316+ stack[base + 49LLU] = stack[base + 2]/*scopes*/;
21317+ stack[base + 50LLU] = stack[base + 3]/*scope*/;
2116921318 // set stack-base & callee-address
21170- base += 45LLU;
21319+ base += 47LLU;
2117121320 label = 659LLU; // emitvar
2117221321 break;
2117321322 }
21174- case 1711LLU: // copy-back deleter (emitvar to ProcCall)
21323+ case 1725LLU: // copy-back deleter (emitvar to ProcCall)
2117521324 {
2117621325 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2117721326 // copy mutable arguments back from call to emitvar
21178- label = 1551LLU; // continue to roll stack
21327+ label = 1565LLU; // continue to roll stack
2117921328 break;
2118021329 }
21181- case 1712LLU: // return from emitvar to ProcCall
21330+ case 1726LLU: // return from emitvar to ProcCall
2118221331 {
2118321332 // copy mutable arguments back from call to emitvar
2118421333 printf("%s", ";");
2118521334
21186- uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
21335+ uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4);
2118721336 // call ~letdef from ProcCall
2118821337 newstack[0] = (uint64_t)stack; // backup stack location
2118921338 newstack[1] = 1234567890;
2119021339 newstack[2] = base;
21191- newstack[3] = 1713LLU;
21340+ newstack[3] = 1727LLU;
2119221341 stack = newstack;
2119321342 // set stack-base & callee-address
2119421343 base = 4/*deloffset*/;
@@ -21195,234 +21344,234 @@
2119521344 label = 438LLU; // ~letdef
2119621345 break;
2119721346 }
21198- case 1713LLU: // return from ~letdef to ProcCall
21347+ case 1727LLU: // return from ~letdef to ProcCall
2119921348 {
2120021349 stack = (uint64_t *)stack[0];
2120121350 // releasing toplevel container
21202- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4));
21351+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2120321352
21204- label = 1621LLU; // alternative complete
21353+ label = 1635LLU; // alternative complete
2120521354 break;
2120621355 }
21207- case 1621LLU: // completed if-then-else
21356+ case 1635LLU: // completed if-then-else
2120821357 {
21209- ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
21210- ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
21211- label = 1616LLU; // case complete
21358+ ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
21359+ ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
21360+ label = 1630LLU; // case complete
2121221361 break;
2121321362 }
21214- case 1617LLU: // try next case
21363+ case 1631LLU: // try next case
2121521364 {
2121621365 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2121721366 exit(-1);
2121821367 }
21219- case 1616LLU: // completed switch
21368+ case 1630LLU: // completed switch
2122021369 {
21221- ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
21222- ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
21223- label = 1614LLU; // case complete
21370+ ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
21371+ ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
21372+ label = 1628LLU; // case complete
2122421373 break;
2122521374 }
21226- case 1615LLU: // try next case
21375+ case 1629LLU: // try next case
2122721376 {
2122821377 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2122921378 exit(-1);
2123021379 }
21231- case 1614LLU: // completed switch
21380+ case 1628LLU: // completed switch
2123221381 {
21233- label = 1613LLU; // consequent complete
21382+ label = 1627LLU; // consequent complete
2123421383 break;
2123521384 }
21236- case 1612LLU: // alternative
21385+ case 1626LLU: // alternative
2123721386 {
2123821387 fprintf(stderr, "%s", "in function ");
2123921388 // call reportid from ProcCall
21240- stack[base + 37LLU] = 1714LLU/*throw to this address*/;
21241- stack[base + 38LLU] = base;
21242- stack[base + 39LLU] = 1715LLU;
21389+ stack[base + 39LLU] = 1728LLU/*throw to this address*/;
21390+ stack[base + 40LLU] = base;
21391+ stack[base + 41LLU] = 1729LLU;
2124321392 // arguments for call to reportid
21244- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
21393+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2124521394 // set stack-base & callee-address
21246- base += 40LLU;
21395+ base += 42LLU;
2124721396 label = 18446744073709551586LLU; // reportid
2124821397 break;
2124921398 }
21250- case 1714LLU: // copy-back deleter (reportid to ProcCall)
21399+ case 1728LLU: // copy-back deleter (reportid to ProcCall)
2125121400 {
2125221401 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2125321402 // copy mutable arguments back from call to reportid
21254- label = 1551LLU; // continue to roll stack
21403+ label = 1565LLU; // continue to roll stack
2125521404 break;
2125621405 }
21257- case 1715LLU: // return from reportid to ProcCall
21406+ case 1729LLU: // return from reportid to ProcCall
2125821407 {
2125921408 // copy mutable arguments back from call to reportid
2126021409 fprintf(stderr, "%s", " call to ");
2126121410 // call reportid from ProcCall
21262- stack[base + 37LLU] = 1716LLU/*throw to this address*/;
21263- stack[base + 38LLU] = base;
21264- stack[base + 39LLU] = 1717LLU;
21411+ stack[base + 39LLU] = 1730LLU/*throw to this address*/;
21412+ stack[base + 40LLU] = base;
21413+ stack[base + 41LLU] = 1731LLU;
2126521414 // arguments for call to reportid
21266- stack[base + 40LLU] = stack[base + 23]/*ceid*/;
21415+ stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2126721416 // set stack-base & callee-address
21268- base += 40LLU;
21417+ base += 42LLU;
2126921418 label = 18446744073709551586LLU; // reportid
2127021419 break;
2127121420 }
21272- case 1716LLU: // copy-back deleter (reportid to ProcCall)
21421+ case 1730LLU: // copy-back deleter (reportid to ProcCall)
2127321422 {
2127421423 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2127521424 // copy mutable arguments back from call to reportid
21276- label = 1551LLU; // continue to roll stack
21425+ label = 1565LLU; // continue to roll stack
2127721426 break;
2127821427 }
21279- case 1717LLU: // return from reportid to ProcCall
21428+ case 1731LLU: // return from reportid to ProcCall
2128021429 {
2128121430 // copy mutable arguments back from call to reportid
2128221431 fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
2128321432 // call printtoken from ProcCall
21284- stack[base + 37LLU] = 1718LLU/*throw to this address*/;
21285- stack[base + 38LLU] = base;
21286- stack[base + 39LLU] = 1719LLU;
21433+ stack[base + 39LLU] = 1732LLU/*throw to this address*/;
21434+ stack[base + 40LLU] = base;
21435+ stack[base + 41LLU] = 1733LLU;
2128721436 // arguments for call to printtoken
21288- stack[base + 40LLU] = stack[base + 14]/*variant*/;
21289- stack[base + 41LLU] = stack[base + 15]/*content*/;
21437+ stack[base + 42LLU] = stack[base + 15]/*variant*/;
21438+ stack[base + 43LLU] = stack[base + 16]/*content*/;
2129021439 // set stack-base & callee-address
21291- base += 40LLU;
21440+ base += 42LLU;
2129221441 label = 18446744073709551583LLU; // printtoken
2129321442 break;
2129421443 }
21295- case 1718LLU: // copy-back deleter (printtoken to ProcCall)
21444+ case 1732LLU: // copy-back deleter (printtoken to ProcCall)
2129621445 {
2129721446 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n");
2129821447 // copy mutable arguments back from call to printtoken
21299- label = 1551LLU; // continue to roll stack
21448+ label = 1565LLU; // continue to roll stack
2130021449 break;
2130121450 }
21302- case 1719LLU: // return from printtoken to ProcCall
21451+ case 1733LLU: // return from printtoken to ProcCall
2130321452 {
2130421453 // copy mutable arguments back from call to printtoken
2130521454 fprintf(stderr, "%s", "\n");
2130621455 exit(-1);
21307- label = 1613LLU; // alternative complete
21456+ label = 1627LLU; // alternative complete
2130821457 break;
2130921458 }
21310- case 1613LLU: // completed if-then-else
21459+ case 1627LLU: // completed if-then-else
2131121460 {
21312- label = 1574LLU; // alternative complete
21461+ label = 1588LLU; // alternative complete
2131321462 break;
2131421463 }
21315- case 1574LLU: // completed if-then-else
21464+ case 1588LLU: // completed if-then-else
2131621465 {
21317- ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
21318- label = 1553LLU; // repeat
21466+ ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
21467+ label = 1567LLU; // repeat
2131921468 break;
2132021469 }
21321- case 1554LLU: // loop finished
21470+ case 1568LLU: // loop finished
2132221471 {
2132321472 // call equ from ProcCall
21324- stack[base + 37LLU] = 1720LLU/*throw to this address*/;
21325- stack[base + 38LLU] = base;
21326- stack[base + 39LLU] = 1721LLU;
21473+ stack[base + 39LLU] = 1734LLU/*throw to this address*/;
21474+ stack[base + 40LLU] = base;
21475+ stack[base + 41LLU] = 1735LLU;
2132721476 // arguments for call to equ
21328- stack[base + 41LLU] = stack[base + 7]/*fnid*/;
21329- stack[base + 42LLU] = stack[base + 23]/*ceid*/;
21477+ stack[base + 43LLU] = stack[base + 8]/*fnid*/;
21478+ stack[base + 44LLU] = stack[base + 24]/*ceid*/;
2133021479 // set stack-base & callee-address
21331- base += 40LLU;
21480+ base += 42LLU;
2133221481 label = 18446744073709551600LLU; // equ
2133321482 break;
2133421483 }
21335- case 1720LLU: // copy-back deleter (equ to ProcCall)
21484+ case 1734LLU: // copy-back deleter (equ to ProcCall)
2133621485 {
2133721486 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
2133821487 // copy mutable arguments back from call to equ
21339- label = 1551LLU; // continue to roll stack
21488+ label = 1565LLU; // continue to roll stack
2134021489 break;
2134121490 }
21342- case 1721LLU: // return from equ to ProcCall
21491+ case 1735LLU: // return from equ to ProcCall
2134321492 {
2134421493 // copy mutable arguments back from call to equ
2134521494 // copy back results provided by call to equ
21346- stack[base + 17] = stack[base + 40LLU];
21347- if(!stack[base + 17]/*isequal*/)
21495+ stack[base + 18] = stack[base + 42LLU];
21496+ if(!stack[base + 18]/*isequal*/)
2134821497 {
21349- label = 1722LLU; // jump to alternative
21498+ label = 1736LLU; // jump to alternative
2135021499 break;
2135121500 }
2135221501
2135321502 // consequent
21354- if(!stack[base + 33]/*csubstruct*/)
21503+ if(!stack[base + 35]/*csubstruct*/)
2135521504 {
21356- label = 1724LLU; // jump to alternative
21505+ label = 1738LLU; // jump to alternative
2135721506 break;
2135821507 }
2135921508
2136021509 // consequent
21361- label = 1725LLU; // consequent complete
21510+ label = 1739LLU; // consequent complete
2136221511 break;
2136321512 }
21364- case 1724LLU: // alternative
21513+ case 1738LLU: // alternative
2136521514 {
2136621515 fprintf(stderr, "%s", "in function ");
2136721516 // call reportid from ProcCall
21368- stack[base + 37LLU] = 1726LLU/*throw to this address*/;
21369- stack[base + 38LLU] = base;
21370- stack[base + 39LLU] = 1727LLU;
21517+ stack[base + 39LLU] = 1740LLU/*throw to this address*/;
21518+ stack[base + 40LLU] = base;
21519+ stack[base + 41LLU] = 1741LLU;
2137121520 // arguments for call to reportid
21372- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
21521+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2137321522 // set stack-base & callee-address
21374- base += 40LLU;
21523+ base += 42LLU;
2137521524 label = 18446744073709551586LLU; // reportid
2137621525 break;
2137721526 }
21378- case 1726LLU: // copy-back deleter (reportid to ProcCall)
21527+ case 1740LLU: // copy-back deleter (reportid to ProcCall)
2137921528 {
2138021529 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2138121530 // copy mutable arguments back from call to reportid
21382- label = 1551LLU; // continue to roll stack
21531+ label = 1565LLU; // continue to roll stack
2138321532 break;
2138421533 }
21385- case 1727LLU: // return from reportid to ProcCall
21534+ case 1741LLU: // return from reportid to ProcCall
2138621535 {
2138721536 // copy mutable arguments back from call to reportid
2138821537 fprintf(stderr, "%s", " recursive call to ");
2138921538 // call reportid from ProcCall
21390- stack[base + 37LLU] = 1728LLU/*throw to this address*/;
21391- stack[base + 38LLU] = base;
21392- stack[base + 39LLU] = 1729LLU;
21539+ stack[base + 39LLU] = 1742LLU/*throw to this address*/;
21540+ stack[base + 40LLU] = base;
21541+ stack[base + 41LLU] = 1743LLU;
2139321542 // arguments for call to reportid
21394- stack[base + 40LLU] = stack[base + 23]/*ceid*/;
21543+ stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2139521544 // set stack-base & callee-address
21396- base += 40LLU;
21545+ base += 42LLU;
2139721546 label = 18446744073709551586LLU; // reportid
2139821547 break;
2139921548 }
21400- case 1728LLU: // copy-back deleter (reportid to ProcCall)
21549+ case 1742LLU: // copy-back deleter (reportid to ProcCall)
2140121550 {
2140221551 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2140321552 // copy mutable arguments back from call to reportid
21404- label = 1551LLU; // continue to roll stack
21553+ label = 1565LLU; // continue to roll stack
2140521554 break;
2140621555 }
21407- case 1729LLU: // return from reportid to ProcCall
21556+ case 1743LLU: // return from reportid to ProcCall
2140821557 {
2140921558 // copy mutable arguments back from call to reportid
2141021559 fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of parameter obtained by switch)\n");
2141121560 exit(-1);
21412- label = 1725LLU; // alternative complete
21561+ label = 1739LLU; // alternative complete
2141321562 break;
2141421563 }
21415- case 1725LLU: // completed if-then-else
21564+ case 1739LLU: // completed if-then-else
2141621565 {
21417- label = 1723LLU; // consequent complete
21566+ label = 1737LLU; // consequent complete
2141821567 break;
2141921568 }
21420- case 1722LLU: // alternative
21569+ case 1736LLU: // alternative
2142121570 {
21422- label = 1723LLU; // alternative complete
21571+ label = 1737LLU; // alternative complete
2142321572 break;
2142421573 }
21425- case 1723LLU: // completed if-then-else
21574+ case 1737LLU: // completed if-then-else
2142621575 {
2142721576 printf("%s", "\n stack = newstack;");
2142821577 printf("%s", "\n // set stack-base & callee-address");
@@ -21429,46 +21578,46 @@
2142921578 printf("%s", "\n base = 4/*deloffset*/;");
2143021579 printf("%s", "\n label = ");
2143121580 // call printnr from ProcCall
21432- stack[base + 33LLU] = 1730LLU/*throw to this address*/;
21433- stack[base + 34LLU] = base;
21434- stack[base + 35LLU] = 1731LLU;
21581+ stack[base + 35LLU] = 1744LLU/*throw to this address*/;
21582+ stack[base + 36LLU] = base;
21583+ stack[base + 37LLU] = 1745LLU;
2143521584 // arguments for call to printnr
21436- stack[base + 36LLU] = stack[base + 19]/*celabel*/;
21585+ stack[base + 38LLU] = stack[base + 20]/*celabel*/;
2143721586 // set stack-base & callee-address
21438- base += 36LLU;
21587+ base += 38LLU;
2143921588 label = 18446744073709551590LLU; // printnr
2144021589 break;
2144121590 }
21442- case 1730LLU: // copy-back deleter (printnr to ProcCall)
21591+ case 1744LLU: // copy-back deleter (printnr to ProcCall)
2144321592 {
2144421593 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2144521594 // copy mutable arguments back from call to printnr
21446- label = 1523LLU; // continue to roll stack
21595+ label = 1537LLU; // continue to roll stack
2144721596 break;
2144821597 }
21449- case 1731LLU: // return from printnr to ProcCall
21598+ case 1745LLU: // return from printnr to ProcCall
2145021599 {
2145121600 // copy mutable arguments back from call to printnr
2145221601 printf("%s", "LLU; // ");
2145321602 // call printid from ProcCall
21454- stack[base + 33LLU] = 1732LLU/*throw to this address*/;
21455- stack[base + 34LLU] = base;
21456- stack[base + 35LLU] = 1733LLU;
21603+ stack[base + 35LLU] = 1746LLU/*throw to this address*/;
21604+ stack[base + 36LLU] = base;
21605+ stack[base + 37LLU] = 1747LLU;
2145721606 // arguments for call to printid
21458- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
21607+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2145921608 // set stack-base & callee-address
21460- base += 36LLU;
21609+ base += 38LLU;
2146121610 label = 18446744073709551587LLU; // printid
2146221611 break;
2146321612 }
21464- case 1732LLU: // copy-back deleter (printid to ProcCall)
21613+ case 1746LLU: // copy-back deleter (printid to ProcCall)
2146521614 {
2146621615 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2146721616 // copy mutable arguments back from call to printid
21468- label = 1523LLU; // continue to roll stack
21617+ label = 1537LLU; // continue to roll stack
2146921618 break;
2147021619 }
21471- case 1733LLU: // return from printid to ProcCall
21620+ case 1747LLU: // return from printid to ProcCall
2147221621 {
2147321622 // copy mutable arguments back from call to printid
2147421623 printf("%s", "\n break;");
@@ -21475,78 +21624,78 @@
2147521624 printf("%s", "\n }");
2147621625 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2147721626 {
21478- label = 1735LLU; // jump to alternative
21627+ label = 1749LLU; // jump to alternative
2147921628 break;
2148021629 }
2148121630
21482- /*labelthrow*/stack[base + 33] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/;
21483- /*dummy*/stack[base + 34] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/;
21631+ /*labelthrow*/stack[base + 35] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/;
21632+ /*dummy*/stack[base + 36] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/;
2148421633
2148521634 // case
2148621635 printf("%s", "\n case ");
2148721636 // call printnr from ProcCall
21488- stack[base + 35LLU] = 1736LLU/*throw to this address*/;
21489- stack[base + 36LLU] = base;
21490- stack[base + 37LLU] = 1737LLU;
21637+ stack[base + 37LLU] = 1750LLU/*throw to this address*/;
21638+ stack[base + 38LLU] = base;
21639+ stack[base + 39LLU] = 1751LLU;
2149121640 // arguments for call to printnr
21492- stack[base + 38LLU] = stack[base + 31]/*labelfail*/;
21641+ stack[base + 40LLU] = stack[base + 33]/*labelfail*/;
2149321642 // set stack-base & callee-address
21494- base += 38LLU;
21643+ base += 40LLU;
2149521644 label = 18446744073709551590LLU; // printnr
2149621645 break;
2149721646 }
21498- case 1736LLU: // copy-back deleter (printnr to ProcCall)
21647+ case 1750LLU: // copy-back deleter (printnr to ProcCall)
2149921648 {
2150021649 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2150121650 // copy mutable arguments back from call to printnr
21502- label = 1523LLU; // continue to roll stack
21651+ label = 1537LLU; // continue to roll stack
2150321652 break;
2150421653 }
21505- case 1737LLU: // return from printnr to ProcCall
21654+ case 1751LLU: // return from printnr to ProcCall
2150621655 {
2150721656 // copy mutable arguments back from call to printnr
2150821657 printf("%s", "LLU: // copy-back deleter (");
2150921658 // call printid from ProcCall
21510- stack[base + 35LLU] = 1738LLU/*throw to this address*/;
21511- stack[base + 36LLU] = base;
21512- stack[base + 37LLU] = 1739LLU;
21659+ stack[base + 37LLU] = 1752LLU/*throw to this address*/;
21660+ stack[base + 38LLU] = base;
21661+ stack[base + 39LLU] = 1753LLU;
2151321662 // arguments for call to printid
21514- stack[base + 38LLU] = stack[base + 23]/*ceid*/;
21663+ stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2151521664 // set stack-base & callee-address
21516- base += 38LLU;
21665+ base += 40LLU;
2151721666 label = 18446744073709551587LLU; // printid
2151821667 break;
2151921668 }
21520- case 1738LLU: // copy-back deleter (printid to ProcCall)
21669+ case 1752LLU: // copy-back deleter (printid to ProcCall)
2152121670 {
2152221671 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2152321672 // copy mutable arguments back from call to printid
21524- label = 1523LLU; // continue to roll stack
21673+ label = 1537LLU; // continue to roll stack
2152521674 break;
2152621675 }
21527- case 1739LLU: // return from printid to ProcCall
21676+ case 1753LLU: // return from printid to ProcCall
2152821677 {
2152921678 // copy mutable arguments back from call to printid
2153021679 printf("%s", " to ");
2153121680 // call printid from ProcCall
21532- stack[base + 35LLU] = 1740LLU/*throw to this address*/;
21533- stack[base + 36LLU] = base;
21534- stack[base + 37LLU] = 1741LLU;
21681+ stack[base + 37LLU] = 1754LLU/*throw to this address*/;
21682+ stack[base + 38LLU] = base;
21683+ stack[base + 39LLU] = 1755LLU;
2153521684 // arguments for call to printid
21536- stack[base + 38LLU] = stack[base + 7]/*fnid*/;
21685+ stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2153721686 // set stack-base & callee-address
21538- base += 38LLU;
21687+ base += 40LLU;
2153921688 label = 18446744073709551587LLU; // printid
2154021689 break;
2154121690 }
21542- case 1740LLU: // copy-back deleter (printid to ProcCall)
21691+ case 1754LLU: // copy-back deleter (printid to ProcCall)
2154321692 {
2154421693 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2154521694 // copy mutable arguments back from call to printid
21546- label = 1523LLU; // continue to roll stack
21695+ label = 1537LLU; // continue to roll stack
2154721696 break;
2154821697 }
21549- case 1741LLU: // return from printid to ProcCall
21698+ case 1755LLU: // return from printid to ProcCall
2155021699 {
2155121700 // copy mutable arguments back from call to printid
2155221701 printf("%s", ")");
@@ -21553,68 +21702,68 @@
2155321702 printf("%s", "\n {");
2155421703 printf("%s", "\n fprintf(stderr, \"in function ");
2155521704 // call printid from ProcCall
21556- stack[base + 35LLU] = 1742LLU/*throw to this address*/;
21557- stack[base + 36LLU] = base;
21558- stack[base + 37LLU] = 1743LLU;
21705+ stack[base + 37LLU] = 1756LLU/*throw to this address*/;
21706+ stack[base + 38LLU] = base;
21707+ stack[base + 39LLU] = 1757LLU;
2155921708 // arguments for call to printid
21560- stack[base + 38LLU] = stack[base + 7]/*fnid*/;
21709+ stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2156121710 // set stack-base & callee-address
21562- base += 38LLU;
21711+ base += 40LLU;
2156321712 label = 18446744073709551587LLU; // printid
2156421713 break;
2156521714 }
21566- case 1742LLU: // copy-back deleter (printid to ProcCall)
21715+ case 1756LLU: // copy-back deleter (printid to ProcCall)
2156721716 {
2156821717 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2156921718 // copy mutable arguments back from call to printid
21570- label = 1523LLU; // continue to roll stack
21719+ label = 1537LLU; // continue to roll stack
2157121720 break;
2157221721 }
21573- case 1743LLU: // return from printid to ProcCall
21722+ case 1757LLU: // return from printid to ProcCall
2157421723 {
2157521724 // copy mutable arguments back from call to printid
2157621725 printf("%s", ": unrolling stack, copy-back (");
2157721726 // call printid from ProcCall
21578- stack[base + 35LLU] = 1744LLU/*throw to this address*/;
21579- stack[base + 36LLU] = base;
21580- stack[base + 37LLU] = 1745LLU;
21727+ stack[base + 37LLU] = 1758LLU/*throw to this address*/;
21728+ stack[base + 38LLU] = base;
21729+ stack[base + 39LLU] = 1759LLU;
2158121730 // arguments for call to printid
21582- stack[base + 38LLU] = stack[base + 23]/*ceid*/;
21731+ stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2158321732 // set stack-base & callee-address
21584- base += 38LLU;
21733+ base += 40LLU;
2158521734 label = 18446744073709551587LLU; // printid
2158621735 break;
2158721736 }
21588- case 1744LLU: // copy-back deleter (printid to ProcCall)
21737+ case 1758LLU: // copy-back deleter (printid to ProcCall)
2158921738 {
2159021739 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2159121740 // copy mutable arguments back from call to printid
21592- label = 1523LLU; // continue to roll stack
21741+ label = 1537LLU; // continue to roll stack
2159321742 break;
2159421743 }
21595- case 1745LLU: // return from printid to ProcCall
21744+ case 1759LLU: // return from printid to ProcCall
2159621745 {
2159721746 // copy mutable arguments back from call to printid
2159821747 printf("%s", " to ");
2159921748 // call printid from ProcCall
21600- stack[base + 35LLU] = 1746LLU/*throw to this address*/;
21601- stack[base + 36LLU] = base;
21602- stack[base + 37LLU] = 1747LLU;
21749+ stack[base + 37LLU] = 1760LLU/*throw to this address*/;
21750+ stack[base + 38LLU] = base;
21751+ stack[base + 39LLU] = 1761LLU;
2160321752 // arguments for call to printid
21604- stack[base + 38LLU] = stack[base + 7]/*fnid*/;
21753+ stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2160521754 // set stack-base & callee-address
21606- base += 38LLU;
21755+ base += 40LLU;
2160721756 label = 18446744073709551587LLU; // printid
2160821757 break;
2160921758 }
21610- case 1746LLU: // copy-back deleter (printid to ProcCall)
21759+ case 1760LLU: // copy-back deleter (printid to ProcCall)
2161121760 {
2161221761 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2161321762 // copy mutable arguments back from call to printid
21614- label = 1523LLU; // continue to roll stack
21763+ label = 1537LLU; // continue to roll stack
2161521764 break;
2161621765 }
21617- case 1747LLU: // return from printid to ProcCall
21766+ case 1761LLU: // return from printid to ProcCall
2161821767 {
2161921768 // copy mutable arguments back from call to printid
2162021769 printf("%s", ")");
@@ -21622,138 +21771,138 @@
2162221771 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2162321772 printf("%s", "\n // copy mutable arguments back from call to ");
2162421773 // call printid from ProcCall
21625- stack[base + 35LLU] = 1748LLU/*throw to this address*/;
21626- stack[base + 36LLU] = base;
21627- stack[base + 37LLU] = 1749LLU;
21774+ stack[base + 37LLU] = 1762LLU/*throw to this address*/;
21775+ stack[base + 38LLU] = base;
21776+ stack[base + 39LLU] = 1763LLU;
2162821777 // arguments for call to printid
21629- stack[base + 38LLU] = stack[base + 23]/*ceid*/;
21778+ stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2163021779 // set stack-base & callee-address
21631- base += 38LLU;
21780+ base += 40LLU;
2163221781 label = 18446744073709551587LLU; // printid
2163321782 break;
2163421783 }
21635- case 1748LLU: // copy-back deleter (printid to ProcCall)
21784+ case 1762LLU: // copy-back deleter (printid to ProcCall)
2163621785 {
2163721786 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2163821787 // copy mutable arguments back from call to printid
21639- label = 1523LLU; // continue to roll stack
21788+ label = 1537LLU; // continue to roll stack
2164021789 break;
2164121790 }
21642- case 1749LLU: // return from printid to ProcCall
21791+ case 1763LLU: // return from printid to ProcCall
2164321792 {
2164421793 // copy mutable arguments back from call to printid
21645- flippedassign(stack[base + 18]/*copyback*/, &stack[base + 35]);
21646- label = 1750LLU; // start to repeat
21794+ flippedassign(stack[base + 19]/*copyback*/, &stack[base + 37]);
21795+ label = 1764LLU; // start to repeat
2164721796 break;
2164821797 }
21649- case 1750LLU: // repeat from here
21798+ case 1764LLU: // repeat from here
2165021799 {
21651- if(!stack[base + 35])
21800+ if(!stack[base + 37])
2165221801 {
21653- label = 1751LLU; // break loop
21802+ label = 1765LLU; // break loop
2165421803 break;
2165521804 }
2165621805
2165721806 // loop body
21658- stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->data);
21659- stack[base + 37]/*previous*/ = stack[base + 35];
21660- stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next);
21661- if(/*idnr*/0 != ((uint64_t *)(stack[base + 36]/*idnr*/))[0])
21807+ stack[base + 38] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->data);
21808+ stack[base + 39]/*previous*/ = stack[base + 37];
21809+ stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->next);
21810+ if(/*idnr*/0 != ((uint64_t *)(stack[base + 38]/*idnr*/))[0])
2166221811 {
21663- label = 1753LLU; // jump to alternative
21812+ label = 1767LLU; // jump to alternative
2166421813 break;
2166521814 }
2166621815
21667- /*content*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*idnr*/))[1][0]/*id*/;
21668- /*sum*/stack[base + 39] = ((uint64_t **)(stack[base + 36]/*idnr*/))[1][1]/*nr*/;
21816+ /*content*/stack[base + 40] = ((uint64_t **)(stack[base + 38]/*idnr*/))[1][0]/*id*/;
21817+ /*sum*/stack[base + 41] = ((uint64_t **)(stack[base + 38]/*idnr*/))[1][1]/*nr*/;
2166921818
2167021819 // case
2167121820 printf("%s", "\n old");
2167221821 // call emitvar from ProcCall
21673- stack[base + 40LLU] = 1754LLU/*throw to this address*/;
21674- stack[base + 41LLU] = base;
21675- stack[base + 42LLU] = 1755LLU;
21822+ stack[base + 42LLU] = 1768LLU/*throw to this address*/;
21823+ stack[base + 43LLU] = base;
21824+ stack[base + 44LLU] = 1769LLU;
2167621825 // arguments for call to emitvar
21677- stack[base + 43LLU] = stack[base + 7]/*fnid*/;
21678- stack[base + 44LLU] = stack[base + 38]/*content*/;
21679- stack[base + 45LLU] = stack[base + 2]/*scopes*/;
21680- stack[base + 46LLU] = stack[base + 3]/*scope*/;
21826+ stack[base + 45LLU] = stack[base + 8]/*fnid*/;
21827+ stack[base + 46LLU] = stack[base + 40]/*content*/;
21828+ stack[base + 47LLU] = stack[base + 2]/*scopes*/;
21829+ stack[base + 48LLU] = stack[base + 3]/*scope*/;
2168121830 // set stack-base & callee-address
21682- base += 43LLU;
21831+ base += 45LLU;
2168321832 label = 659LLU; // emitvar
2168421833 break;
2168521834 }
21686- case 1754LLU: // copy-back deleter (emitvar to ProcCall)
21835+ case 1768LLU: // copy-back deleter (emitvar to ProcCall)
2168721836 {
2168821837 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2168921838 // copy mutable arguments back from call to emitvar
21690- label = 1523LLU; // continue to roll stack
21839+ label = 1537LLU; // continue to roll stack
2169121840 break;
2169221841 }
21693- case 1755LLU: // return from emitvar to ProcCall
21842+ case 1769LLU: // return from emitvar to ProcCall
2169421843 {
2169521844 // copy mutable arguments back from call to emitvar
2169621845 printf("%s", " = stack[");
2169721846 // call printnr from ProcCall
21698- stack[base + 40LLU] = 1756LLU/*throw to this address*/;
21699- stack[base + 41LLU] = base;
21700- stack[base + 42LLU] = 1757LLU;
21847+ stack[base + 42LLU] = 1770LLU/*throw to this address*/;
21848+ stack[base + 43LLU] = base;
21849+ stack[base + 44LLU] = 1771LLU;
2170121850 // arguments for call to printnr
21702- stack[base + 43LLU] = stack[base + 39]/*sum*/;
21851+ stack[base + 45LLU] = stack[base + 41]/*sum*/;
2170321852 // set stack-base & callee-address
21704- base += 43LLU;
21853+ base += 45LLU;
2170521854 label = 18446744073709551590LLU; // printnr
2170621855 break;
2170721856 }
21708- case 1756LLU: // copy-back deleter (printnr to ProcCall)
21857+ case 1770LLU: // copy-back deleter (printnr to ProcCall)
2170921858 {
2171021859 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2171121860 // copy mutable arguments back from call to printnr
21712- label = 1523LLU; // continue to roll stack
21861+ label = 1537LLU; // continue to roll stack
2171321862 break;
2171421863 }
21715- case 1757LLU: // return from printnr to ProcCall
21864+ case 1771LLU: // return from printnr to ProcCall
2171621865 {
2171721866 // copy mutable arguments back from call to printnr
2171821867 printf("%s", "LLU];");
21719- ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39];
21720- ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38];
21721- label = 1752LLU; // case complete
21868+ ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
21869+ ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
21870+ label = 1766LLU; // case complete
2172221871 break;
2172321872 }
21724- case 1753LLU: // try next case
21873+ case 1767LLU: // try next case
2172521874 {
2172621875 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2172721876 exit(-1);
2172821877 }
21729- case 1752LLU: // completed switch
21878+ case 1766LLU: // completed switch
2173021879 {
21731- ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
21732- label = 1750LLU; // repeat
21880+ ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
21881+ label = 1764LLU; // repeat
2173321882 break;
2173421883 }
21735- case 1751LLU: // loop finished
21884+ case 1765LLU: // loop finished
2173621885 {
2173721886 printf("%s", "\n if(stack[");
2173821887 // call printnr from ProcCall
21739- stack[base + 38LLU] = 1758LLU/*throw to this address*/;
21740- stack[base + 39LLU] = base;
21741- stack[base + 40LLU] = 1759LLU;
21888+ stack[base + 40LLU] = 1772LLU/*throw to this address*/;
21889+ stack[base + 41LLU] = base;
21890+ stack[base + 42LLU] = 1773LLU;
2174221891 // arguments for call to printnr
21743- stack[base + 41LLU] = stack[base + 32]/*recsztotal*/;
21892+ stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2174421893 // set stack-base & callee-address
21745- base += 41LLU;
21894+ base += 43LLU;
2174621895 label = 18446744073709551590LLU; // printnr
2174721896 break;
2174821897 }
21749- case 1758LLU: // copy-back deleter (printnr to ProcCall)
21898+ case 1772LLU: // copy-back deleter (printnr to ProcCall)
2175021899 {
2175121900 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2175221901 // copy mutable arguments back from call to printnr
21753- label = 1523LLU; // continue to roll stack
21902+ label = 1537LLU; // continue to roll stack
2175421903 break;
2175521904 }
21756- case 1759LLU: // return from printnr to ProcCall
21905+ case 1773LLU: // return from printnr to ProcCall
2175721906 {
2175821907 // copy mutable arguments back from call to printnr
2175921908 printf("%s", "LLU] != 9876543210LLU)");
@@ -21760,24 +21909,24 @@
2176021909 printf("%s", "\n {");
2176121910 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2176221911 // call printid from ProcCall
21763- stack[base + 38LLU] = 1760LLU/*throw to this address*/;
21764- stack[base + 39LLU] = base;
21765- stack[base + 40LLU] = 1761LLU;
21912+ stack[base + 40LLU] = 1774LLU/*throw to this address*/;
21913+ stack[base + 41LLU] = base;
21914+ stack[base + 42LLU] = 1775LLU;
2176621915 // arguments for call to printid
21767- stack[base + 41LLU] = stack[base + 23]/*ceid*/;
21916+ stack[base + 43LLU] = stack[base + 24]/*ceid*/;
2176821917 // set stack-base & callee-address
21769- base += 41LLU;
21918+ base += 43LLU;
2177021919 label = 18446744073709551587LLU; // printid
2177121920 break;
2177221921 }
21773- case 1760LLU: // copy-back deleter (printid to ProcCall)
21922+ case 1774LLU: // copy-back deleter (printid to ProcCall)
2177421923 {
2177521924 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2177621925 // copy mutable arguments back from call to printid
21777- label = 1523LLU; // continue to roll stack
21926+ label = 1537LLU; // continue to roll stack
2177821927 break;
2177921928 }
21780- case 1761LLU: // return from printid to ProcCall
21929+ case 1775LLU: // return from printid to ProcCall
2178121930 {
2178221931 // copy mutable arguments back from call to printid
2178321932 printf("%s", ")!\");");
@@ -21785,24 +21934,24 @@
2178521934 printf("%s", "\n }");
2178621935 printf("%s", "\n Free(");
2178721936 // call printnr from ProcCall
21788- stack[base + 38LLU] = 1762LLU/*throw to this address*/;
21789- stack[base + 39LLU] = base;
21790- stack[base + 40LLU] = 1763LLU;
21937+ stack[base + 40LLU] = 1776LLU/*throw to this address*/;
21938+ stack[base + 41LLU] = base;
21939+ stack[base + 42LLU] = 1777LLU;
2179121940 // arguments for call to printnr
21792- stack[base + 41LLU] = stack[base + 32]/*recsztotal*/;
21941+ stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2179321942 // set stack-base & callee-address
21794- base += 41LLU;
21943+ base += 43LLU;
2179521944 label = 18446744073709551590LLU; // printnr
2179621945 break;
2179721946 }
21798- case 1762LLU: // copy-back deleter (printnr to ProcCall)
21947+ case 1776LLU: // copy-back deleter (printnr to ProcCall)
2179921948 {
2180021949 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2180121950 // copy mutable arguments back from call to printnr
21802- label = 1523LLU; // continue to roll stack
21951+ label = 1537LLU; // continue to roll stack
2180321952 break;
2180421953 }
21805- case 1763LLU: // return from printnr to ProcCall
21954+ case 1777LLU: // return from printnr to ProcCall
2180621955 {
2180721956 // copy mutable arguments back from call to printnr
2180821957 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
@@ -21809,105 +21958,105 @@
2180921958 printf("%s", "\n stack = oldstack;");
2181021959 printf("%s", "\n label = ");
2181121960 // call printnr from ProcCall
21812- stack[base + 38LLU] = 1764LLU/*throw to this address*/;
21813- stack[base + 39LLU] = base;
21814- stack[base + 40LLU] = 1765LLU;
21961+ stack[base + 40LLU] = 1778LLU/*throw to this address*/;
21962+ stack[base + 41LLU] = base;
21963+ stack[base + 42LLU] = 1779LLU;
2181521964 // arguments for call to printnr
21816- stack[base + 41LLU] = stack[base + 33]/*labelthrow*/;
21965+ stack[base + 43LLU] = stack[base + 35]/*labelthrow*/;
2181721966 // set stack-base & callee-address
21818- base += 41LLU;
21967+ base += 43LLU;
2181921968 label = 18446744073709551590LLU; // printnr
2182021969 break;
2182121970 }
21822- case 1764LLU: // copy-back deleter (printnr to ProcCall)
21971+ case 1778LLU: // copy-back deleter (printnr to ProcCall)
2182321972 {
2182421973 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2182521974 // copy mutable arguments back from call to printnr
21826- label = 1523LLU; // continue to roll stack
21975+ label = 1537LLU; // continue to roll stack
2182721976 break;
2182821977 }
21829- case 1765LLU: // return from printnr to ProcCall
21978+ case 1779LLU: // return from printnr to ProcCall
2183021979 {
2183121980 // copy mutable arguments back from call to printnr
2183221981 printf("%s", "LLU; // continue to unroll stack");
2183321982 printf("%s", "\n break;");
2183421983 printf("%s", "\n }");
21835- ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 34];
21836- ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 33];
21837- label = 1734LLU; // case complete
21984+ ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
21985+ ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
21986+ label = 1748LLU; // case complete
2183821987 break;
2183921988 }
21840- case 1735LLU: // try next case
21989+ case 1749LLU: // try next case
2184121990 {
2184221991 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2184321992 exit(-1);
2184421993 }
21845- case 1734LLU: // completed switch
21994+ case 1748LLU: // completed switch
2184621995 {
2184721996 printf("%s", "\n case ");
2184821997 // call printnr from ProcCall
21849- stack[base + 33LLU] = 1766LLU/*throw to this address*/;
21850- stack[base + 34LLU] = base;
21851- stack[base + 35LLU] = 1767LLU;
21998+ stack[base + 35LLU] = 1780LLU/*throw to this address*/;
21999+ stack[base + 36LLU] = base;
22000+ stack[base + 37LLU] = 1781LLU;
2185222001 // arguments for call to printnr
21853- stack[base + 36LLU] = stack[base + 16]/*label*/;
22002+ stack[base + 38LLU] = stack[base + 17]/*label*/;
2185422003 // set stack-base & callee-address
21855- base += 36LLU;
22004+ base += 38LLU;
2185622005 label = 18446744073709551590LLU; // printnr
2185722006 break;
2185822007 }
21859- case 1766LLU: // copy-back deleter (printnr to ProcCall)
22008+ case 1780LLU: // copy-back deleter (printnr to ProcCall)
2186022009 {
2186122010 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2186222011 // copy mutable arguments back from call to printnr
21863- label = 1523LLU; // continue to roll stack
22012+ label = 1537LLU; // continue to roll stack
2186422013 break;
2186522014 }
21866- case 1767LLU: // return from printnr to ProcCall
22015+ case 1781LLU: // return from printnr to ProcCall
2186722016 {
2186822017 // copy mutable arguments back from call to printnr
2186922018 printf("%s", "LLU: // return from ");
2187022019 // call printid from ProcCall
21871- stack[base + 33LLU] = 1768LLU/*throw to this address*/;
21872- stack[base + 34LLU] = base;
21873- stack[base + 35LLU] = 1769LLU;
22020+ stack[base + 35LLU] = 1782LLU/*throw to this address*/;
22021+ stack[base + 36LLU] = base;
22022+ stack[base + 37LLU] = 1783LLU;
2187422023 // arguments for call to printid
21875- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
22024+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2187622025 // set stack-base & callee-address
21877- base += 36LLU;
22026+ base += 38LLU;
2187822027 label = 18446744073709551587LLU; // printid
2187922028 break;
2188022029 }
21881- case 1768LLU: // copy-back deleter (printid to ProcCall)
22030+ case 1782LLU: // copy-back deleter (printid to ProcCall)
2188222031 {
2188322032 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2188422033 // copy mutable arguments back from call to printid
21885- label = 1523LLU; // continue to roll stack
22034+ label = 1537LLU; // continue to roll stack
2188622035 break;
2188722036 }
21888- case 1769LLU: // return from printid to ProcCall
22037+ case 1783LLU: // return from printid to ProcCall
2188922038 {
2189022039 // copy mutable arguments back from call to printid
2189122040 printf("%s", " to ");
2189222041 // call printid from ProcCall
21893- stack[base + 33LLU] = 1770LLU/*throw to this address*/;
21894- stack[base + 34LLU] = base;
21895- stack[base + 35LLU] = 1771LLU;
22042+ stack[base + 35LLU] = 1784LLU/*throw to this address*/;
22043+ stack[base + 36LLU] = base;
22044+ stack[base + 37LLU] = 1785LLU;
2189622045 // arguments for call to printid
21897- stack[base + 36LLU] = stack[base + 7]/*fnid*/;
22046+ stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2189822047 // set stack-base & callee-address
21899- base += 36LLU;
22048+ base += 38LLU;
2190022049 label = 18446744073709551587LLU; // printid
2190122050 break;
2190222051 }
21903- case 1770LLU: // copy-back deleter (printid to ProcCall)
22052+ case 1784LLU: // copy-back deleter (printid to ProcCall)
2190422053 {
2190522054 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2190622055 // copy mutable arguments back from call to printid
21907- label = 1523LLU; // continue to roll stack
22056+ label = 1537LLU; // continue to roll stack
2190822057 break;
2190922058 }
21910- case 1771LLU: // return from printid to ProcCall
22059+ case 1785LLU: // return from printid to ProcCall
2191122060 {
2191222061 // copy mutable arguments back from call to printid
2191322062 printf("%s", "\n {");
@@ -21914,121 +22063,121 @@
2191422063 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2191522064 printf("%s", "\n // copy mutable arguments back from call to ");
2191622065 // call printid from ProcCall
21917- stack[base + 33LLU] = 1772LLU/*throw to this address*/;
21918- stack[base + 34LLU] = base;
21919- stack[base + 35LLU] = 1773LLU;
22066+ stack[base + 35LLU] = 1786LLU/*throw to this address*/;
22067+ stack[base + 36LLU] = base;
22068+ stack[base + 37LLU] = 1787LLU;
2192022069 // arguments for call to printid
21921- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
22070+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2192222071 // set stack-base & callee-address
21923- base += 36LLU;
22072+ base += 38LLU;
2192422073 label = 18446744073709551587LLU; // printid
2192522074 break;
2192622075 }
21927- case 1772LLU: // copy-back deleter (printid to ProcCall)
22076+ case 1786LLU: // copy-back deleter (printid to ProcCall)
2192822077 {
2192922078 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2193022079 // copy mutable arguments back from call to printid
21931- label = 1523LLU; // continue to roll stack
22080+ label = 1537LLU; // continue to roll stack
2193222081 break;
2193322082 }
21934- case 1773LLU: // return from printid to ProcCall
22083+ case 1787LLU: // return from printid to ProcCall
2193522084 {
2193622085 // copy mutable arguments back from call to printid
21937- label = 1774LLU; // start to repeat
22086+ label = 1788LLU; // start to repeat
2193822087 break;
2193922088 }
21940- case 1774LLU: // repeat from here
22089+ case 1788LLU: // repeat from here
2194122090 {
21942- if(!stack[base + 18])
22091+ if(!stack[base + 19])
2194322092 {
21944- label = 1775LLU; // break loop
22093+ label = 1789LLU; // break loop
2194522094 break;
2194622095 }
2194722096
2194822097 // loop body
21949- stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->data);
22098+ stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->data);
2195022099 {
21951- struct listnode *list = (struct listnode *)(stack[base + 18]);
21952- stack[base + 18] = (uint64_t)list->next;
22100+ struct listnode *list = (struct listnode *)(stack[base + 19]);
22101+ stack[base + 19] = (uint64_t)list->next;
2195322102 Free(1, sizeof(struct listnode), list);
2195422103 }
21955- if(/*idnr*/0 != ((uint64_t *)(stack[base + 33]/*idnr*/))[0])
22104+ if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0])
2195622105 {
21957- label = 1777LLU; // jump to alternative
22106+ label = 1791LLU; // jump to alternative
2195822107 break;
2195922108 }
2196022109
21961- /*content*/stack[base + 34] = ((uint64_t **)(stack[base + 33]/*idnr*/))[1][0]/*id*/;
21962- /*sum*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*idnr*/))[1][1]/*nr*/;
22110+ /*content*/stack[base + 36] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][0]/*id*/;
22111+ /*sum*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][1]/*nr*/;
2196322112
2196422113 // case
2196522114 printf("%s", "\n old");
2196622115 // call emitvar from ProcCall
21967- stack[base + 36LLU] = 1778LLU/*throw to this address*/;
21968- stack[base + 37LLU] = base;
21969- stack[base + 38LLU] = 1779LLU;
22116+ stack[base + 38LLU] = 1792LLU/*throw to this address*/;
22117+ stack[base + 39LLU] = base;
22118+ stack[base + 40LLU] = 1793LLU;
2197022119 // arguments for call to emitvar
21971- stack[base + 39LLU] = stack[base + 7]/*fnid*/;
21972- stack[base + 40LLU] = stack[base + 34]/*content*/;
21973- stack[base + 41LLU] = stack[base + 2]/*scopes*/;
21974- stack[base + 42LLU] = stack[base + 3]/*scope*/;
22120+ stack[base + 41LLU] = stack[base + 8]/*fnid*/;
22121+ stack[base + 42LLU] = stack[base + 36]/*content*/;
22122+ stack[base + 43LLU] = stack[base + 2]/*scopes*/;
22123+ stack[base + 44LLU] = stack[base + 3]/*scope*/;
2197522124 // set stack-base & callee-address
21976- base += 39LLU;
22125+ base += 41LLU;
2197722126 label = 659LLU; // emitvar
2197822127 break;
2197922128 }
21980- case 1778LLU: // copy-back deleter (emitvar to ProcCall)
22129+ case 1792LLU: // copy-back deleter (emitvar to ProcCall)
2198122130 {
2198222131 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2198322132 // copy mutable arguments back from call to emitvar
21984- label = 1523LLU; // continue to roll stack
22133+ label = 1537LLU; // continue to roll stack
2198522134 break;
2198622135 }
21987- case 1779LLU: // return from emitvar to ProcCall
22136+ case 1793LLU: // return from emitvar to ProcCall
2198822137 {
2198922138 // copy mutable arguments back from call to emitvar
2199022139 printf("%s", " = stack[");
2199122140 // call printnr from ProcCall
21992- stack[base + 36LLU] = 1780LLU/*throw to this address*/;
21993- stack[base + 37LLU] = base;
21994- stack[base + 38LLU] = 1781LLU;
22141+ stack[base + 38LLU] = 1794LLU/*throw to this address*/;
22142+ stack[base + 39LLU] = base;
22143+ stack[base + 40LLU] = 1795LLU;
2199522144 // arguments for call to printnr
21996- stack[base + 39LLU] = stack[base + 35]/*sum*/;
22145+ stack[base + 41LLU] = stack[base + 37]/*sum*/;
2199722146 // set stack-base & callee-address
21998- base += 39LLU;
22147+ base += 41LLU;
2199922148 label = 18446744073709551590LLU; // printnr
2200022149 break;
2200122150 }
22002- case 1780LLU: // copy-back deleter (printnr to ProcCall)
22151+ case 1794LLU: // copy-back deleter (printnr to ProcCall)
2200322152 {
2200422153 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2200522154 // copy mutable arguments back from call to printnr
22006- label = 1523LLU; // continue to roll stack
22155+ label = 1537LLU; // continue to roll stack
2200722156 break;
2200822157 }
22009- case 1781LLU: // return from printnr to ProcCall
22158+ case 1795LLU: // return from printnr to ProcCall
2201022159 {
2201122160 // copy mutable arguments back from call to printnr
2201222161 printf("%s", "LLU];");
22013- ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 35];
22014- ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 34];
22015- label = 1776LLU; // case complete
22162+ ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
22163+ ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
22164+ label = 1790LLU; // case complete
2201622165 break;
2201722166 }
22018- case 1777LLU: // try next case
22167+ case 1791LLU: // try next case
2201922168 {
2202022169 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2202122170 exit(-1);
2202222171 }
22023- case 1776LLU: // completed switch
22172+ case 1790LLU: // completed switch
2202422173 {
2202522174
22026- uint64_t *newstack = (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4);
22175+ uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
2202722176 // call ~idnr from ProcCall
2202822177 newstack[0] = (uint64_t)stack; // backup stack location
2202922178 newstack[1] = 1234567890;
2203022179 newstack[2] = base;
22031- newstack[3] = 1782LLU;
22180+ newstack[3] = 1796LLU;
2203222181 stack = newstack;
2203322182 // set stack-base & callee-address
2203422183 base = 4/*deloffset*/;
@@ -22035,20 +22184,20 @@
2203522184 label = 758LLU; // ~idnr
2203622185 break;
2203722186 }
22038- case 1782LLU: // return from ~idnr to ProcCall
22187+ case 1796LLU: // return from ~idnr to ProcCall
2203922188 {
2204022189 stack = (uint64_t *)stack[0];
2204122190 // releasing toplevel container
22042- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4));
22191+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2204322192
22044- label = 1774LLU; // repeat
22193+ label = 1788LLU; // repeat
2204522194 break;
2204622195 }
22047- case 1775LLU: // loop finished
22196+ case 1789LLU: // loop finished
2204822197 {
22049- if(!stack[base + 26]/*cerescount*/)
22198+ if(!stack[base + 28]/*cerescount*/)
2205022199 {
22051- label = 1783LLU; // jump to alternative
22200+ label = 1797LLU; // jump to alternative
2205222201 break;
2205322202 }
2205422203
@@ -22055,129 +22204,129 @@
2205522204 // consequent
2205622205 printf("%s", "\n // copy back results provided by call to ");
2205722206 // call printid from ProcCall
22058- stack[base + 33LLU] = 1785LLU/*throw to this address*/;
22059- stack[base + 34LLU] = base;
22060- stack[base + 35LLU] = 1786LLU;
22207+ stack[base + 35LLU] = 1799LLU/*throw to this address*/;
22208+ stack[base + 36LLU] = base;
22209+ stack[base + 37LLU] = 1800LLU;
2206122210 // arguments for call to printid
22062- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
22211+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2206322212 // set stack-base & callee-address
22064- base += 36LLU;
22213+ base += 38LLU;
2206522214 label = 18446744073709551587LLU; // printid
2206622215 break;
2206722216 }
22068- case 1785LLU: // copy-back deleter (printid to ProcCall)
22217+ case 1799LLU: // copy-back deleter (printid to ProcCall)
2206922218 {
2207022219 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2207122220 // copy mutable arguments back from call to printid
22072- label = 1523LLU; // continue to roll stack
22221+ label = 1537LLU; // continue to roll stack
2207322222 break;
2207422223 }
22075- case 1786LLU: // return from printid to ProcCall
22224+ case 1800LLU: // return from printid to ProcCall
2207622225 {
2207722226 // copy mutable arguments back from call to printid
22078- stack[base + 29]/*n*/ = stack[base + 26]/*cerescount*/;
22079- flippedassign(stack[base + 20]/*cerestypes*/, &stack[base + 33]);
22080- label = 1787LLU; // start to repeat
22227+ stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/;
22228+ flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 35]);
22229+ label = 1801LLU; // start to repeat
2208122230 break;
2208222231 }
22083- case 1787LLU: // repeat from here
22232+ case 1801LLU: // repeat from here
2208422233 {
22085- if(!stack[base + 33])
22234+ if(!stack[base + 35])
2208622235 {
22087- label = 1788LLU; // break loop
22236+ label = 1802LLU; // break loop
2208822237 break;
2208922238 }
2209022239
2209122240 // loop body
22092- stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->data);
22093- stack[base + 35]/*previous*/ = stack[base + 33];
22094- stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next);
22241+ stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->data);
22242+ stack[base + 37]/*previous*/ = stack[base + 35];
22243+ stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next);
2209522244 // call sub from ProcCall
22096- stack[base + 36LLU] = 1789LLU/*throw to this address*/;
22097- stack[base + 37LLU] = base;
22098- stack[base + 38LLU] = 1790LLU;
22245+ stack[base + 38LLU] = 1803LLU/*throw to this address*/;
22246+ stack[base + 39LLU] = base;
22247+ stack[base + 40LLU] = 1804LLU;
2209922248 // arguments for call to sub
22100- stack[base + 40LLU] = stack[base + 26]/*cerescount*/;
22101- stack[base + 41LLU] = stack[base + 29]/*n*/;
22249+ stack[base + 42LLU] = stack[base + 28]/*cerescount*/;
22250+ stack[base + 43LLU] = stack[base + 31]/*n*/;
2210222251 // set stack-base & callee-address
22103- base += 39LLU;
22252+ base += 41LLU;
2210422253 label = 18446744073709551604LLU; // sub
2210522254 break;
2210622255 }
22107- case 1789LLU: // copy-back deleter (sub to ProcCall)
22256+ case 1803LLU: // copy-back deleter (sub to ProcCall)
2210822257 {
2210922258 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2211022259 // copy mutable arguments back from call to sub
22111- label = 1523LLU; // continue to roll stack
22260+ label = 1537LLU; // continue to roll stack
2211222261 break;
2211322262 }
22114- case 1790LLU: // return from sub to ProcCall
22263+ case 1804LLU: // return from sub to ProcCall
2211522264 {
2211622265 // copy mutable arguments back from call to sub
2211722266 // copy back results provided by call to sub
22118- stack[base + 30] = stack[base + 39LLU];
22267+ stack[base + 32] = stack[base + 41LLU];
2211922268 // call sub from ProcCall
22120- stack[base + 36LLU] = 1791LLU/*throw to this address*/;
22121- stack[base + 37LLU] = base;
22122- stack[base + 38LLU] = 1792LLU;
22269+ stack[base + 38LLU] = 1805LLU/*throw to this address*/;
22270+ stack[base + 39LLU] = base;
22271+ stack[base + 40LLU] = 1806LLU;
2212322272 // arguments for call to sub
22124- stack[base + 40LLU] = stack[base + 29]/*n*/;
22125- stack[base + 41LLU] = 1LLU;
22273+ stack[base + 42LLU] = stack[base + 31]/*n*/;
22274+ stack[base + 43LLU] = 1LLU;
2212622275 // set stack-base & callee-address
22127- base += 39LLU;
22276+ base += 41LLU;
2212822277 label = 18446744073709551604LLU; // sub
2212922278 break;
2213022279 }
22131- case 1791LLU: // copy-back deleter (sub to ProcCall)
22280+ case 1805LLU: // copy-back deleter (sub to ProcCall)
2213222281 {
2213322282 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2213422283 // copy mutable arguments back from call to sub
22135- label = 1523LLU; // continue to roll stack
22284+ label = 1537LLU; // continue to roll stack
2213622285 break;
2213722286 }
22138- case 1792LLU: // return from sub to ProcCall
22287+ case 1806LLU: // return from sub to ProcCall
2213922288 {
2214022289 // copy mutable arguments back from call to sub
2214122290 // copy back results provided by call to sub
22142- stack[base + 29] = stack[base + 39LLU];
22291+ stack[base + 31] = stack[base + 41LLU];
2214322292 { // if pop
2214422293 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
2214522294 if(!list)
2214622295 {
22147- label = 1793LLU; // jump to alternative
22296+ label = 1807LLU; // jump to alternative
2214822297 break;
2214922298 }
2215022299
2215122300 // consequent
2215222301 struct listnode *next = list->next;
22153- stack[base + 36]/*typeidx*/ = list->data;
22302+ stack[base + 38]/*typeidx*/ = list->data;
2215422303 Free(1, sizeof(struct listnode), list);
2215522304 stack[base + 0]/*dsttypeids*/ = (uint64_t)next;
2215622305 }
22157- if(/*typeidx*/0 != ((uint64_t *)(stack[base + 36]/*typeidx*/))[0])
22306+ if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0])
2215822307 {
22159- label = 1796LLU; // jump to alternative
22308+ label = 1810LLU; // jump to alternative
2216022309 break;
2216122310 }
2216222311
22163- /*dsttype*/stack[base + 37] = ((uint64_t **)(stack[base + 36]/*typeidx*/))[1][0]/*type*/;
22164- /*INDEX*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*typeidx*/))[1][1]/*idx*/;
22312+ /*dsttype*/stack[base + 39] = ((uint64_t **)(stack[base + 38]/*typeidx*/))[1][0]/*type*/;
22313+ /*INDEX*/stack[base + 40] = ((uint64_t **)(stack[base + 38]/*typeidx*/))[1][1]/*idx*/;
2216522314
2216622315 // case
22167- if(/*result*/0 != ((uint64_t *)(stack[base + 34]/*result*/))[0])
22316+ if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0])
2216822317 {
22169- label = 1798LLU; // jump to alternative
22318+ label = 1812LLU; // jump to alternative
2217022319 break;
2217122320 }
2217222321
22173- /*srctype*/stack[base + 39] = ((uint64_t **)(stack[base + 34]/*result*/))[1][0]/*type*/;
22174- /*RESERVED*/stack[base + 40] = ((uint64_t **)(stack[base + 34]/*result*/))[1][1]/*RESERVED*/;
22322+ /*srctype*/stack[base + 41] = ((uint64_t **)(stack[base + 36]/*result*/))[1][0]/*type*/;
22323+ /*RESERVED*/stack[base + 42] = ((uint64_t **)(stack[base + 36]/*result*/))[1][1]/*RESERVED*/;
2217522324
2217622325 // case
2217722326 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2217822327 if(!newstack)
2217922328 {
22180- label = 1523LLU; // throw: begin to unroll stack
22329+ label = 1537LLU; // throw: begin to unroll stack
2218122330 break;
2218222331 }
2218322332
@@ -22184,12 +22333,12 @@
2218422333 newstack[15LLU] = 9876543210LLU; // overflow-marker
2218522334 // call equtype from ProcCall
2218622335 newstack[0] = (uint64_t)stack; // backup stack location
22187- newstack[1] = 1799LLU;
22336+ newstack[1] = 1813LLU;
2218822337 newstack[2] = base;
22189- newstack[3] = 1800LLU;
22338+ newstack[3] = 1814LLU;
2219022339 // arguments for call to equtype
22191- newstack[5LLU] = stack[base + 37]/*dsttype*/;
22192- newstack[6LLU] = stack[base + 39]/*srctype*/;
22340+ newstack[5LLU] = stack[base + 39]/*dsttype*/;
22341+ newstack[6LLU] = stack[base + 41]/*srctype*/;
2219322342 stack = newstack;
2219422343 // set stack-base & callee-address
2219522344 base = 4/*deloffset*/;
@@ -22196,7 +22345,7 @@
2219622345 label = 335LLU; // equtype
2219722346 break;
2219822347 }
22199- case 1799LLU: // copy-back deleter (equtype to ProcCall)
22348+ case 1813LLU: // copy-back deleter (equtype to ProcCall)
2220022349 {
2220122350 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2220222351 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -22208,15 +22357,15 @@
2220822357 }
2220922358 Free(15LLU + 1, sizeof(uint64_t), stack);
2221022359 stack = oldstack;
22211- label = 1523LLU; // continue to unroll stack
22360+ label = 1537LLU; // continue to unroll stack
2221222361 break;
2221322362 }
22214- case 1800LLU: // return from equtype to ProcCall
22363+ case 1814LLU: // return from equtype to ProcCall
2221522364 {
2221622365 uint64_t *oldstack = (uint64_t *)stack[0];
2221722366 // copy mutable arguments back from call to equtype
2221822367 // copy back results provided by call to equtype
22219- oldstack[base + 17] = stack[4LLU];
22368+ oldstack[base + 18] = stack[4LLU];
2222022369 if(stack[15LLU] != 9876543210LLU)
2222122370 {
2222222371 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -22224,82 +22373,82 @@
2222422373 }
2222522374 Free(15LLU + 1, sizeof(uint64_t), stack);
2222622375 stack = oldstack;
22227- if(!stack[base + 17]/*isequal*/)
22376+ if(!stack[base + 18]/*isequal*/)
2222822377 {
22229- label = 1801LLU; // jump to alternative
22378+ label = 1815LLU; // jump to alternative
2223022379 break;
2223122380 }
2223222381
2223322382 // consequent
22234- label = 1802LLU; // consequent complete
22383+ label = 1816LLU; // consequent complete
2223522384 break;
2223622385 }
22237- case 1801LLU: // alternative
22386+ case 1815LLU: // alternative
2223822387 {
2223922388 fprintf(stderr, "%s", "in function ");
2224022389 // call reportid from ProcCall
22241- stack[base + 41LLU] = 1803LLU/*throw to this address*/;
22242- stack[base + 42LLU] = base;
22243- stack[base + 43LLU] = 1804LLU;
22390+ stack[base + 43LLU] = 1817LLU/*throw to this address*/;
22391+ stack[base + 44LLU] = base;
22392+ stack[base + 45LLU] = 1818LLU;
2224422393 // arguments for call to reportid
22245- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
22394+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2224622395 // set stack-base & callee-address
22247- base += 44LLU;
22396+ base += 46LLU;
2224822397 label = 18446744073709551586LLU; // reportid
2224922398 break;
2225022399 }
22251- case 1803LLU: // copy-back deleter (reportid to ProcCall)
22400+ case 1817LLU: // copy-back deleter (reportid to ProcCall)
2225222401 {
2225322402 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2225422403 // copy mutable arguments back from call to reportid
22255- label = 1523LLU; // continue to roll stack
22404+ label = 1537LLU; // continue to roll stack
2225622405 break;
2225722406 }
22258- case 1804LLU: // return from reportid to ProcCall
22407+ case 1818LLU: // return from reportid to ProcCall
2225922408 {
2226022409 // copy mutable arguments back from call to reportid
2226122410 fprintf(stderr, "%s", " call to ");
2226222411 // call reportid from ProcCall
22263- stack[base + 41LLU] = 1805LLU/*throw to this address*/;
22264- stack[base + 42LLU] = base;
22265- stack[base + 43LLU] = 1806LLU;
22412+ stack[base + 43LLU] = 1819LLU/*throw to this address*/;
22413+ stack[base + 44LLU] = base;
22414+ stack[base + 45LLU] = 1820LLU;
2226622415 // arguments for call to reportid
22267- stack[base + 44LLU] = stack[base + 23]/*ceid*/;
22416+ stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2226822417 // set stack-base & callee-address
22269- base += 44LLU;
22418+ base += 46LLU;
2227022419 label = 18446744073709551586LLU; // reportid
2227122420 break;
2227222421 }
22273- case 1805LLU: // copy-back deleter (reportid to ProcCall)
22422+ case 1819LLU: // copy-back deleter (reportid to ProcCall)
2227422423 {
2227522424 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2227622425 // copy mutable arguments back from call to reportid
22277- label = 1523LLU; // continue to roll stack
22426+ label = 1537LLU; // continue to roll stack
2227822427 break;
2227922428 }
22280- case 1806LLU: // return from reportid to ProcCall
22429+ case 1820LLU: // return from reportid to ProcCall
2228122430 {
2228222431 // copy mutable arguments back from call to reportid
2228322432 fprintf(stderr, "%s", " at position ");
2228422433 // call reportnr from ProcCall
22285- stack[base + 41LLU] = 1807LLU/*throw to this address*/;
22286- stack[base + 42LLU] = base;
22287- stack[base + 43LLU] = 1808LLU;
22434+ stack[base + 43LLU] = 1821LLU/*throw to this address*/;
22435+ stack[base + 44LLU] = base;
22436+ stack[base + 45LLU] = 1822LLU;
2228822437 // arguments for call to reportnr
22289- stack[base + 44LLU] = stack[base + 30]/*index*/;
22438+ stack[base + 46LLU] = stack[base + 32]/*index*/;
2229022439 // set stack-base & callee-address
22291- base += 44LLU;
22440+ base += 46LLU;
2229222441 label = 18446744073709551589LLU; // reportnr
2229322442 break;
2229422443 }
22295- case 1807LLU: // copy-back deleter (reportnr to ProcCall)
22444+ case 1821LLU: // copy-back deleter (reportnr to ProcCall)
2229622445 {
2229722446 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2229822447 // copy mutable arguments back from call to reportnr
22299- label = 1523LLU; // continue to roll stack
22448+ label = 1537LLU; // continue to roll stack
2230022449 break;
2230122450 }
22302- case 1808LLU: // return from reportnr to ProcCall
22451+ case 1822LLU: // return from reportnr to ProcCall
2230322452 {
2230422453 // copy mutable arguments back from call to reportnr
2230522454 fprintf(stderr, "%s", " cannot return source of type ");
@@ -22306,7 +22455,7 @@
2230622455 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2230722456 if(!newstack)
2230822457 {
22309- label = 1523LLU; // throw: begin to unroll stack
22458+ label = 1537LLU; // throw: begin to unroll stack
2231022459 break;
2231122460 }
2231222461
@@ -22313,11 +22462,11 @@
2231322462 newstack[10LLU] = 9876543210LLU; // overflow-marker
2231422463 // call reporttype from ProcCall
2231522464 newstack[0] = (uint64_t)stack; // backup stack location
22316- newstack[1] = 1809LLU;
22465+ newstack[1] = 1823LLU;
2231722466 newstack[2] = base;
22318- newstack[3] = 1810LLU;
22467+ newstack[3] = 1824LLU;
2231922468 // arguments for call to reporttype
22320- newstack[4LLU] = stack[base + 39]/*srctype*/;
22469+ newstack[4LLU] = stack[base + 41]/*srctype*/;
2232122470 stack = newstack;
2232222471 // set stack-base & callee-address
2232322472 base = 4/*deloffset*/;
@@ -22324,7 +22473,7 @@
2232422473 label = 313LLU; // reporttype
2232522474 break;
2232622475 }
22327- case 1809LLU: // copy-back deleter (reporttype to ProcCall)
22476+ case 1823LLU: // copy-back deleter (reporttype to ProcCall)
2232822477 {
2232922478 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2233022479 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -22336,10 +22485,10 @@
2233622485 }
2233722486 Free(10LLU + 1, sizeof(uint64_t), stack);
2233822487 stack = oldstack;
22339- label = 1523LLU; // continue to unroll stack
22488+ label = 1537LLU; // continue to unroll stack
2234022489 break;
2234122490 }
22342- case 1810LLU: // return from reporttype to ProcCall
22491+ case 1824LLU: // return from reporttype to ProcCall
2234322492 {
2234422493 uint64_t *oldstack = (uint64_t *)stack[0];
2234522494 // copy mutable arguments back from call to reporttype
@@ -22354,7 +22503,7 @@
2235422503 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2235522504 if(!newstack)
2235622505 {
22357- label = 1523LLU; // throw: begin to unroll stack
22506+ label = 1537LLU; // throw: begin to unroll stack
2235822507 break;
2235922508 }
2236022509
@@ -22361,11 +22510,11 @@
2236122510 newstack[10LLU] = 9876543210LLU; // overflow-marker
2236222511 // call reporttype from ProcCall
2236322512 newstack[0] = (uint64_t)stack; // backup stack location
22364- newstack[1] = 1811LLU;
22513+ newstack[1] = 1825LLU;
2236522514 newstack[2] = base;
22366- newstack[3] = 1812LLU;
22515+ newstack[3] = 1826LLU;
2236722516 // arguments for call to reporttype
22368- newstack[4LLU] = stack[base + 37]/*dsttype*/;
22517+ newstack[4LLU] = stack[base + 39]/*dsttype*/;
2236922518 stack = newstack;
2237022519 // set stack-base & callee-address
2237122520 base = 4/*deloffset*/;
@@ -22372,7 +22521,7 @@
2237222521 label = 313LLU; // reporttype
2237322522 break;
2237422523 }
22375- case 1811LLU: // copy-back deleter (reporttype to ProcCall)
22524+ case 1825LLU: // copy-back deleter (reporttype to ProcCall)
2237622525 {
2237722526 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2237822527 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -22384,10 +22533,10 @@
2238422533 }
2238522534 Free(10LLU + 1, sizeof(uint64_t), stack);
2238622535 stack = oldstack;
22387- label = 1523LLU; // continue to unroll stack
22536+ label = 1537LLU; // continue to unroll stack
2238822537 break;
2238922538 }
22390- case 1812LLU: // return from reporttype to ProcCall
22539+ case 1826LLU: // return from reporttype to ProcCall
2239122540 {
2239222541 uint64_t *oldstack = (uint64_t *)stack[0];
2239322542 // copy mutable arguments back from call to reporttype
@@ -22400,136 +22549,136 @@
2240022549 stack = oldstack;
2240122550 fprintf(stderr, "%s", "\n");
2240222551 exit(-1);
22403- label = 1802LLU; // alternative complete
22552+ label = 1816LLU; // alternative complete
2240422553 break;
2240522554 }
22406- case 1802LLU: // completed if-then-else
22555+ case 1816LLU: // completed if-then-else
2240722556 {
22408- stack[base + 28]/*sum*/ = 0;
22557+ stack[base + 30]/*sum*/ = 0;
2240922558 // call add from ProcCall
22410- stack[base + 41LLU] = 1813LLU/*throw to this address*/;
22411- stack[base + 42LLU] = base;
22412- stack[base + 43LLU] = 1814LLU;
22559+ stack[base + 43LLU] = 1827LLU/*throw to this address*/;
22560+ stack[base + 44LLU] = base;
22561+ stack[base + 45LLU] = 1828LLU;
2241322562 // arguments for call to add
22414- stack[base + 45LLU] = 4LLU;
22415- stack[base + 46LLU] = stack[base + 28]/*sum*/;
22563+ stack[base + 47LLU] = 4LLU;
22564+ stack[base + 48LLU] = stack[base + 30]/*sum*/;
2241622565 // set stack-base & callee-address
22417- base += 44LLU;
22566+ base += 46LLU;
2241822567 label = 18446744073709551605LLU; // add
2241922568 break;
2242022569 }
22421- case 1813LLU: // copy-back deleter (add to ProcCall)
22570+ case 1827LLU: // copy-back deleter (add to ProcCall)
2242222571 {
2242322572 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2242422573 // copy mutable arguments back from call to add
22425- label = 1523LLU; // continue to roll stack
22574+ label = 1537LLU; // continue to roll stack
2242622575 break;
2242722576 }
22428- case 1814LLU: // return from add to ProcCall
22577+ case 1828LLU: // return from add to ProcCall
2242922578 {
2243022579 // copy mutable arguments back from call to add
2243122580 // copy back results provided by call to add
22432- stack[base + 28] = stack[base + 44LLU];
22581+ stack[base + 30] = stack[base + 46LLU];
2243322582 // call add from ProcCall
22434- stack[base + 41LLU] = 1815LLU/*throw to this address*/;
22435- stack[base + 42LLU] = base;
22436- stack[base + 43LLU] = 1816LLU;
22583+ stack[base + 43LLU] = 1829LLU/*throw to this address*/;
22584+ stack[base + 44LLU] = base;
22585+ stack[base + 45LLU] = 1830LLU;
2243722586 // arguments for call to add
22438- stack[base + 45LLU] = stack[base + 30]/*index*/;
22439- stack[base + 46LLU] = stack[base + 28]/*sum*/;
22587+ stack[base + 47LLU] = stack[base + 32]/*index*/;
22588+ stack[base + 48LLU] = stack[base + 30]/*sum*/;
2244022589 // set stack-base & callee-address
22441- base += 44LLU;
22590+ base += 46LLU;
2244222591 label = 18446744073709551605LLU; // add
2244322592 break;
2244422593 }
22445- case 1815LLU: // copy-back deleter (add to ProcCall)
22594+ case 1829LLU: // copy-back deleter (add to ProcCall)
2244622595 {
2244722596 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2244822597 // copy mutable arguments back from call to add
22449- label = 1523LLU; // continue to roll stack
22598+ label = 1537LLU; // continue to roll stack
2245022599 break;
2245122600 }
22452- case 1816LLU: // return from add to ProcCall
22601+ case 1830LLU: // return from add to ProcCall
2245322602 {
2245422603 // copy mutable arguments back from call to add
2245522604 // copy back results provided by call to add
22456- stack[base + 28] = stack[base + 44LLU];
22605+ stack[base + 30] = stack[base + 46LLU];
2245722606 printf("%s", "\n old");
2245822607 // call emitvaridx from ProcCall
22459- stack[base + 41LLU] = 1817LLU/*throw to this address*/;
22460- stack[base + 42LLU] = base;
22461- stack[base + 43LLU] = 1818LLU;
22608+ stack[base + 43LLU] = 1831LLU/*throw to this address*/;
22609+ stack[base + 44LLU] = base;
22610+ stack[base + 45LLU] = 1832LLU;
2246222611 // arguments for call to emitvaridx
22463- stack[base + 44LLU] = stack[base + 38]/*INDEX*/;
22612+ stack[base + 46LLU] = stack[base + 40]/*INDEX*/;
2246422613 // set stack-base & callee-address
22465- base += 44LLU;
22614+ base += 46LLU;
2246622615 label = 655LLU; // emitvaridx
2246722616 break;
2246822617 }
22469- case 1817LLU: // copy-back deleter (emitvaridx to ProcCall)
22618+ case 1831LLU: // copy-back deleter (emitvaridx to ProcCall)
2247022619 {
2247122620 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n");
2247222621 // copy mutable arguments back from call to emitvaridx
22473- label = 1523LLU; // continue to roll stack
22622+ label = 1537LLU; // continue to roll stack
2247422623 break;
2247522624 }
22476- case 1818LLU: // return from emitvaridx to ProcCall
22625+ case 1832LLU: // return from emitvaridx to ProcCall
2247722626 {
2247822627 // copy mutable arguments back from call to emitvaridx
2247922628 printf("%s", " = stack[");
2248022629 // call printnr from ProcCall
22481- stack[base + 41LLU] = 1819LLU/*throw to this address*/;
22482- stack[base + 42LLU] = base;
22483- stack[base + 43LLU] = 1820LLU;
22630+ stack[base + 43LLU] = 1833LLU/*throw to this address*/;
22631+ stack[base + 44LLU] = base;
22632+ stack[base + 45LLU] = 1834LLU;
2248422633 // arguments for call to printnr
22485- stack[base + 44LLU] = stack[base + 28]/*sum*/;
22634+ stack[base + 46LLU] = stack[base + 30]/*sum*/;
2248622635 // set stack-base & callee-address
22487- base += 44LLU;
22636+ base += 46LLU;
2248822637 label = 18446744073709551590LLU; // printnr
2248922638 break;
2249022639 }
22491- case 1819LLU: // copy-back deleter (printnr to ProcCall)
22640+ case 1833LLU: // copy-back deleter (printnr to ProcCall)
2249222641 {
2249322642 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2249422643 // copy mutable arguments back from call to printnr
22495- label = 1523LLU; // continue to roll stack
22644+ label = 1537LLU; // continue to roll stack
2249622645 break;
2249722646 }
22498- case 1820LLU: // return from printnr to ProcCall
22647+ case 1834LLU: // return from printnr to ProcCall
2249922648 {
2250022649 // copy mutable arguments back from call to printnr
2250122650 printf("%s", "LLU];");
22502- ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40];
22503- ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39];
22504- label = 1797LLU; // case complete
22651+ ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
22652+ ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
22653+ label = 1811LLU; // case complete
2250522654 break;
2250622655 }
22507- case 1798LLU: // try next case
22656+ case 1812LLU: // try next case
2250822657 {
2250922658 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2251022659 exit(-1);
2251122660 }
22512- case 1797LLU: // completed switch
22661+ case 1811LLU: // completed switch
2251322662 {
22514- ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38];
22515- ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37];
22516- label = 1795LLU; // case complete
22663+ ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
22664+ ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
22665+ label = 1809LLU; // case complete
2251722666 break;
2251822667 }
22519- case 1796LLU: // try next case
22668+ case 1810LLU: // try next case
2252022669 {
2252122670 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2252222671 exit(-1);
2252322672 }
22524- case 1795LLU: // completed switch
22673+ case 1809LLU: // completed switch
2252522674 {
2252622675
22527- uint64_t *newstack = (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4);
22676+ uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
2252822677 // call ~typeidx from ProcCall
2252922678 newstack[0] = (uint64_t)stack; // backup stack location
2253022679 newstack[1] = 1234567890;
2253122680 newstack[2] = base;
22532- newstack[3] = 1821LLU;
22681+ newstack[3] = 1835LLU;
2253322682 stack = newstack;
2253422683 // set stack-base & callee-address
2253522684 base = 4/*deloffset*/;
@@ -22536,127 +22685,127 @@
2253622685 label = 368LLU; // ~typeidx
2253722686 break;
2253822687 }
22539- case 1821LLU: // return from ~typeidx to ProcCall
22688+ case 1835LLU: // return from ~typeidx to ProcCall
2254022689 {
2254122690 stack = (uint64_t *)stack[0];
2254222691 // releasing toplevel container
22543- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4));
22692+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2254422693
22545- label = 1794LLU; // consequent complete
22694+ label = 1808LLU; // consequent complete
2254622695 break;
2254722696 }
22548- case 1793LLU: // alternative
22697+ case 1807LLU: // alternative
2254922698 {
2255022699 fprintf(stderr, "%s", "in function ");
2255122700 // call reportid from ProcCall
22552- stack[base + 37LLU] = 1822LLU/*throw to this address*/;
22553- stack[base + 38LLU] = base;
22554- stack[base + 39LLU] = 1823LLU;
22701+ stack[base + 39LLU] = 1836LLU/*throw to this address*/;
22702+ stack[base + 40LLU] = base;
22703+ stack[base + 41LLU] = 1837LLU;
2255522704 // arguments for call to reportid
22556- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
22705+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2255722706 // set stack-base & callee-address
22558- base += 40LLU;
22707+ base += 42LLU;
2255922708 label = 18446744073709551586LLU; // reportid
2256022709 break;
2256122710 }
22562- case 1822LLU: // copy-back deleter (reportid to ProcCall)
22711+ case 1836LLU: // copy-back deleter (reportid to ProcCall)
2256322712 {
2256422713 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2256522714 // copy mutable arguments back from call to reportid
22566- label = 1523LLU; // continue to roll stack
22715+ label = 1537LLU; // continue to roll stack
2256722716 break;
2256822717 }
22569- case 1823LLU: // return from reportid to ProcCall
22718+ case 1837LLU: // return from reportid to ProcCall
2257022719 {
2257122720 // copy mutable arguments back from call to reportid
2257222721 fprintf(stderr, "%s", " call to ");
2257322722 // call reportid from ProcCall
22574- stack[base + 37LLU] = 1824LLU/*throw to this address*/;
22575- stack[base + 38LLU] = base;
22576- stack[base + 39LLU] = 1825LLU;
22723+ stack[base + 39LLU] = 1838LLU/*throw to this address*/;
22724+ stack[base + 40LLU] = base;
22725+ stack[base + 41LLU] = 1839LLU;
2257722726 // arguments for call to reportid
22578- stack[base + 40LLU] = stack[base + 23]/*ceid*/;
22727+ stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2257922728 // set stack-base & callee-address
22580- base += 40LLU;
22729+ base += 42LLU;
2258122730 label = 18446744073709551586LLU; // reportid
2258222731 break;
2258322732 }
22584- case 1824LLU: // copy-back deleter (reportid to ProcCall)
22733+ case 1838LLU: // copy-back deleter (reportid to ProcCall)
2258522734 {
2258622735 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2258722736 // copy mutable arguments back from call to reportid
22588- label = 1523LLU; // continue to roll stack
22737+ label = 1537LLU; // continue to roll stack
2258922738 break;
2259022739 }
22591- case 1825LLU: // return from reportid to ProcCall
22740+ case 1839LLU: // return from reportid to ProcCall
2259222741 {
2259322742 // copy mutable arguments back from call to reportid
2259422743 fprintf(stderr, "%s", " at position ");
2259522744 // call reportnr from ProcCall
22596- stack[base + 37LLU] = 1826LLU/*throw to this address*/;
22597- stack[base + 38LLU] = base;
22598- stack[base + 39LLU] = 1827LLU;
22745+ stack[base + 39LLU] = 1840LLU/*throw to this address*/;
22746+ stack[base + 40LLU] = base;
22747+ stack[base + 41LLU] = 1841LLU;
2259922748 // arguments for call to reportnr
22600- stack[base + 40LLU] = stack[base + 30]/*index*/;
22749+ stack[base + 42LLU] = stack[base + 32]/*index*/;
2260122750 // set stack-base & callee-address
22602- base += 40LLU;
22751+ base += 42LLU;
2260322752 label = 18446744073709551589LLU; // reportnr
2260422753 break;
2260522754 }
22606- case 1826LLU: // copy-back deleter (reportnr to ProcCall)
22755+ case 1840LLU: // copy-back deleter (reportnr to ProcCall)
2260722756 {
2260822757 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2260922758 // copy mutable arguments back from call to reportnr
22610- label = 1523LLU; // continue to roll stack
22759+ label = 1537LLU; // continue to roll stack
2261122760 break;
2261222761 }
22613- case 1827LLU: // return from reportnr to ProcCall
22762+ case 1841LLU: // return from reportnr to ProcCall
2261422763 {
2261522764 // copy mutable arguments back from call to reportnr
2261622765 fprintf(stderr, "%s", " not enough destination-variables for results");
2261722766 fprintf(stderr, "%s", "\n");
2261822767 exit(-1);
22619- label = 1794LLU; // alternative complete
22768+ label = 1808LLU; // alternative complete
2262022769 break;
2262122770 }
22622- case 1794LLU: // completed if-then-else
22771+ case 1808LLU: // completed if-then-else
2262322772 {
22624- ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34];
22625- label = 1787LLU; // repeat
22773+ ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
22774+ label = 1801LLU; // repeat
2262622775 break;
2262722776 }
22628- case 1788LLU: // loop finished
22777+ case 1802LLU: // loop finished
2262922778 {
22630- label = 1784LLU; // consequent complete
22779+ label = 1798LLU; // consequent complete
2263122780 break;
2263222781 }
22633- case 1783LLU: // alternative
22782+ case 1797LLU: // alternative
2263422783 {
22635- label = 1784LLU; // alternative complete
22784+ label = 1798LLU; // alternative complete
2263622785 break;
2263722786 }
22638- case 1784LLU: // completed if-then-else
22787+ case 1798LLU: // completed if-then-else
2263922788 {
2264022789 printf("%s", "\n if(stack[");
2264122790 // call printnr from ProcCall
22642- stack[base + 33LLU] = 1828LLU/*throw to this address*/;
22643- stack[base + 34LLU] = base;
22644- stack[base + 35LLU] = 1829LLU;
22791+ stack[base + 35LLU] = 1842LLU/*throw to this address*/;
22792+ stack[base + 36LLU] = base;
22793+ stack[base + 37LLU] = 1843LLU;
2264522794 // arguments for call to printnr
22646- stack[base + 36LLU] = stack[base + 32]/*recsztotal*/;
22795+ stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2264722796 // set stack-base & callee-address
22648- base += 36LLU;
22797+ base += 38LLU;
2264922798 label = 18446744073709551590LLU; // printnr
2265022799 break;
2265122800 }
22652- case 1828LLU: // copy-back deleter (printnr to ProcCall)
22801+ case 1842LLU: // copy-back deleter (printnr to ProcCall)
2265322802 {
2265422803 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2265522804 // copy mutable arguments back from call to printnr
22656- label = 1523LLU; // continue to roll stack
22805+ label = 1537LLU; // continue to roll stack
2265722806 break;
2265822807 }
22659- case 1829LLU: // return from printnr to ProcCall
22808+ case 1843LLU: // return from printnr to ProcCall
2266022809 {
2266122810 // copy mutable arguments back from call to printnr
2266222811 printf("%s", "LLU] != 9876543210LLU)");
@@ -22663,24 +22812,24 @@
2266322812 printf("%s", "\n {");
2266422813 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2266522814 // call printid from ProcCall
22666- stack[base + 33LLU] = 1830LLU/*throw to this address*/;
22667- stack[base + 34LLU] = base;
22668- stack[base + 35LLU] = 1831LLU;
22815+ stack[base + 35LLU] = 1844LLU/*throw to this address*/;
22816+ stack[base + 36LLU] = base;
22817+ stack[base + 37LLU] = 1845LLU;
2266922818 // arguments for call to printid
22670- stack[base + 36LLU] = stack[base + 23]/*ceid*/;
22819+ stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2267122820 // set stack-base & callee-address
22672- base += 36LLU;
22821+ base += 38LLU;
2267322822 label = 18446744073709551587LLU; // printid
2267422823 break;
2267522824 }
22676- case 1830LLU: // copy-back deleter (printid to ProcCall)
22825+ case 1844LLU: // copy-back deleter (printid to ProcCall)
2267722826 {
2267822827 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2267922828 // copy mutable arguments back from call to printid
22680- label = 1523LLU; // continue to roll stack
22829+ label = 1537LLU; // continue to roll stack
2268122830 break;
2268222831 }
22683- case 1831LLU: // return from printid to ProcCall
22832+ case 1845LLU: // return from printid to ProcCall
2268422833 {
2268522834 // copy mutable arguments back from call to printid
2268622835 printf("%s", ")!\");");
@@ -22688,925 +22837,925 @@
2268822837 printf("%s", "\n }");
2268922838 printf("%s", "\n Free(");
2269022839 // call printnr from ProcCall
22691- stack[base + 33LLU] = 1832LLU/*throw to this address*/;
22692- stack[base + 34LLU] = base;
22693- stack[base + 35LLU] = 1833LLU;
22840+ stack[base + 35LLU] = 1846LLU/*throw to this address*/;
22841+ stack[base + 36LLU] = base;
22842+ stack[base + 37LLU] = 1847LLU;
2269422843 // arguments for call to printnr
22695- stack[base + 36LLU] = stack[base + 32]/*recsztotal*/;
22844+ stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2269622845 // set stack-base & callee-address
22697- base += 36LLU;
22846+ base += 38LLU;
2269822847 label = 18446744073709551590LLU; // printnr
2269922848 break;
2270022849 }
22701- case 1832LLU: // copy-back deleter (printnr to ProcCall)
22850+ case 1846LLU: // copy-back deleter (printnr to ProcCall)
2270222851 {
2270322852 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2270422853 // copy mutable arguments back from call to printnr
22705- label = 1523LLU; // continue to roll stack
22854+ label = 1537LLU; // continue to roll stack
2270622855 break;
2270722856 }
22708- case 1833LLU: // return from printnr to ProcCall
22857+ case 1847LLU: // return from printnr to ProcCall
2270922858 {
2271022859 // copy mutable arguments back from call to printnr
2271122860 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
2271222861 printf("%s", "\n stack = oldstack;");
22713- label = 1518LLU; // consequent complete
22862+ label = 1532LLU; // consequent complete
2271422863 break;
2271522864 }
22716- case 1517LLU: // alternative
22865+ case 1531LLU: // alternative
2271722866 {
2271822867 // call add from ProcCall
22719- stack[base + 31LLU] = 1834LLU/*throw to this address*/;
22720- stack[base + 32LLU] = base;
22721- stack[base + 33LLU] = 1835LLU;
22868+ stack[base + 33LLU] = 1848LLU/*throw to this address*/;
22869+ stack[base + 34LLU] = base;
22870+ stack[base + 35LLU] = 1849LLU;
2272222871 // arguments for call to add
22723- stack[base + 35LLU] = 1LLU;
22724- stack[base + 36LLU] = stack[base + 16]/*label*/;
22872+ stack[base + 37LLU] = 1LLU;
22873+ stack[base + 38LLU] = stack[base + 17]/*label*/;
2272522874 // set stack-base & callee-address
22726- base += 34LLU;
22875+ base += 36LLU;
2272722876 label = 18446744073709551605LLU; // add
2272822877 break;
2272922878 }
22730- case 1834LLU: // copy-back deleter (add to ProcCall)
22879+ case 1848LLU: // copy-back deleter (add to ProcCall)
2273122880 {
2273222881 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2273322882 // copy mutable arguments back from call to add
22734- label = 1515LLU; // continue to roll stack
22883+ label = 1529LLU; // continue to roll stack
2273522884 break;
2273622885 }
22737- case 1835LLU: // return from add to ProcCall
22886+ case 1849LLU: // return from add to ProcCall
2273822887 {
2273922888 // copy mutable arguments back from call to add
2274022889 // copy back results provided by call to add
22741- stack[base + 16] = stack[base + 34LLU];
22742- label = 1837LLU; // skip deleter
22890+ stack[base + 17] = stack[base + 36LLU];
22891+ label = 1851LLU; // skip deleter
2274322892 break;
2274422893 }
22745- case 1836LLU: // deleter
22894+ case 1850LLU: // deleter
2274622895 {
2274722896 // throw from ProcCall
22748- if(!stack[base + 31])
22897+ if(!stack[base + 33])
2274922898 {
2275022899 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
22751- label = 1515LLU; // skip, variable already deleted/unscoped
22900+ label = 1529LLU; // skip, variable already deleted/unscoped
2275222901 break;
2275322902 }
2275422903 fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
22755- label = 1515LLU; // continue unrolling stack, delete next variable
22904+ label = 1529LLU; // continue unrolling stack, delete next variable
2275622905 break;
2275722906 }
22758- case 1837LLU: // skipped deleter
22907+ case 1851LLU: // skipped deleter
2275922908 {
22760- stack[base + 31] = stack[base + 16]/*label*/;
22909+ stack[base + 33] = stack[base + 17]/*label*/;
2276122910 printf("%s", "\n // call ");
2276222911 // call printid from ProcCall
22763- stack[base + 32LLU] = 1838LLU/*throw to this address*/;
22764- stack[base + 33LLU] = base;
22765- stack[base + 34LLU] = 1839LLU;
22912+ stack[base + 34LLU] = 1852LLU/*throw to this address*/;
22913+ stack[base + 35LLU] = base;
22914+ stack[base + 36LLU] = 1853LLU;
2276622915 // arguments for call to printid
22767- stack[base + 35LLU] = stack[base + 23]/*ceid*/;
22916+ stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2276822917 // set stack-base & callee-address
22769- base += 35LLU;
22918+ base += 37LLU;
2277022919 label = 18446744073709551587LLU; // printid
2277122920 break;
2277222921 }
22773- case 1838LLU: // copy-back deleter (printid to ProcCall)
22922+ case 1852LLU: // copy-back deleter (printid to ProcCall)
2277422923 {
2277522924 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2277622925 // copy mutable arguments back from call to printid
22777- label = 1836LLU; // continue to roll stack
22926+ label = 1850LLU; // continue to roll stack
2277822927 break;
2277922928 }
22780- case 1839LLU: // return from printid to ProcCall
22929+ case 1853LLU: // return from printid to ProcCall
2278122930 {
2278222931 // copy mutable arguments back from call to printid
2278322932 printf("%s", " from ");
2278422933 // call printid from ProcCall
22785- stack[base + 32LLU] = 1840LLU/*throw to this address*/;
22786- stack[base + 33LLU] = base;
22787- stack[base + 34LLU] = 1841LLU;
22934+ stack[base + 34LLU] = 1854LLU/*throw to this address*/;
22935+ stack[base + 35LLU] = base;
22936+ stack[base + 36LLU] = 1855LLU;
2278822937 // arguments for call to printid
22789- stack[base + 35LLU] = stack[base + 7]/*fnid*/;
22938+ stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2279022939 // set stack-base & callee-address
22791- base += 35LLU;
22940+ base += 37LLU;
2279222941 label = 18446744073709551587LLU; // printid
2279322942 break;
2279422943 }
22795- case 1840LLU: // copy-back deleter (printid to ProcCall)
22944+ case 1854LLU: // copy-back deleter (printid to ProcCall)
2279622945 {
2279722946 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2279822947 // copy mutable arguments back from call to printid
22799- label = 1836LLU; // continue to roll stack
22948+ label = 1850LLU; // continue to roll stack
2280022949 break;
2280122950 }
22802- case 1841LLU: // return from printid to ProcCall
22951+ case 1855LLU: // return from printid to ProcCall
2280322952 {
2280422953 // copy mutable arguments back from call to printid
22805- stack[base + 28]/*sum*/ = 0;
22954+ stack[base + 30]/*sum*/ = 0;
2280622955 // call add from ProcCall
22807- stack[base + 32LLU] = 1842LLU/*throw to this address*/;
22808- stack[base + 33LLU] = base;
22809- stack[base + 34LLU] = 1843LLU;
22956+ stack[base + 34LLU] = 1856LLU/*throw to this address*/;
22957+ stack[base + 35LLU] = base;
22958+ stack[base + 36LLU] = 1857LLU;
2281022959 // arguments for call to add
22811- stack[base + 36LLU] = stack[base + 4]/*offset*/;
22812- stack[base + 37LLU] = stack[base + 28]/*sum*/;
22960+ stack[base + 38LLU] = stack[base + 4]/*offset*/;
22961+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2281322962 // set stack-base & callee-address
22814- base += 35LLU;
22963+ base += 37LLU;
2281522964 label = 18446744073709551605LLU; // add
2281622965 break;
2281722966 }
22818- case 1842LLU: // copy-back deleter (add to ProcCall)
22967+ case 1856LLU: // copy-back deleter (add to ProcCall)
2281922968 {
2282022969 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2282122970 // copy mutable arguments back from call to add
22822- label = 1836LLU; // continue to roll stack
22971+ label = 1850LLU; // continue to roll stack
2282322972 break;
2282422973 }
22825- case 1843LLU: // return from add to ProcCall
22974+ case 1857LLU: // return from add to ProcCall
2282622975 {
2282722976 // copy mutable arguments back from call to add
2282822977 // copy back results provided by call to add
22829- stack[base + 28] = stack[base + 35LLU];
22978+ stack[base + 30] = stack[base + 37LLU];
2283022979 // call add from ProcCall
22831- stack[base + 32LLU] = 1844LLU/*throw to this address*/;
22832- stack[base + 33LLU] = base;
22833- stack[base + 34LLU] = 1845LLU;
22980+ stack[base + 34LLU] = 1858LLU/*throw to this address*/;
22981+ stack[base + 35LLU] = base;
22982+ stack[base + 36LLU] = 1859LLU;
2283422983 // arguments for call to add
22835- stack[base + 36LLU] = stack[base + 9]/*fnrescount*/;
22836- stack[base + 37LLU] = stack[base + 28]/*sum*/;
22984+ stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
22985+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2283722986 // set stack-base & callee-address
22838- base += 35LLU;
22987+ base += 37LLU;
2283922988 label = 18446744073709551605LLU; // add
2284022989 break;
2284122990 }
22842- case 1844LLU: // copy-back deleter (add to ProcCall)
22991+ case 1858LLU: // copy-back deleter (add to ProcCall)
2284322992 {
2284422993 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2284522994 // copy mutable arguments back from call to add
22846- label = 1836LLU; // continue to roll stack
22995+ label = 1850LLU; // continue to roll stack
2284722996 break;
2284822997 }
22849- case 1845LLU: // return from add to ProcCall
22998+ case 1859LLU: // return from add to ProcCall
2285022999 {
2285123000 // copy mutable arguments back from call to add
2285223001 // copy back results provided by call to add
22853- stack[base + 28] = stack[base + 35LLU];
23002+ stack[base + 30] = stack[base + 37LLU];
2285423003 // call add from ProcCall
22855- stack[base + 32LLU] = 1846LLU/*throw to this address*/;
22856- stack[base + 33LLU] = base;
22857- stack[base + 34LLU] = 1847LLU;
23004+ stack[base + 34LLU] = 1860LLU/*throw to this address*/;
23005+ stack[base + 35LLU] = base;
23006+ stack[base + 36LLU] = 1861LLU;
2285823007 // arguments for call to add
22859- stack[base + 36LLU] = stack[base + 10]/*fnargcount*/;
22860- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23008+ stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
23009+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2286123010 // set stack-base & callee-address
22862- base += 35LLU;
23011+ base += 37LLU;
2286323012 label = 18446744073709551605LLU; // add
2286423013 break;
2286523014 }
22866- case 1846LLU: // copy-back deleter (add to ProcCall)
23015+ case 1860LLU: // copy-back deleter (add to ProcCall)
2286723016 {
2286823017 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2286923018 // copy mutable arguments back from call to add
22870- label = 1836LLU; // continue to roll stack
23019+ label = 1850LLU; // continue to roll stack
2287123020 break;
2287223021 }
22873- case 1847LLU: // return from add to ProcCall
23022+ case 1861LLU: // return from add to ProcCall
2287423023 {
2287523024 // copy mutable arguments back from call to add
2287623025 // copy back results provided by call to add
22877- stack[base + 28] = stack[base + 35LLU];
23026+ stack[base + 30] = stack[base + 37LLU];
2287823027 // call add from ProcCall
22879- stack[base + 32LLU] = 1848LLU/*throw to this address*/;
22880- stack[base + 33LLU] = base;
22881- stack[base + 34LLU] = 1849LLU;
23028+ stack[base + 34LLU] = 1862LLU/*throw to this address*/;
23029+ stack[base + 35LLU] = base;
23030+ stack[base + 36LLU] = 1863LLU;
2288223031 // arguments for call to add
22883- stack[base + 36LLU] = 0LLU;
22884- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23032+ stack[base + 38LLU] = 0LLU;
23033+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2288523034 // set stack-base & callee-address
22886- base += 35LLU;
23035+ base += 37LLU;
2288723036 label = 18446744073709551605LLU; // add
2288823037 break;
2288923038 }
22890- case 1848LLU: // copy-back deleter (add to ProcCall)
23039+ case 1862LLU: // copy-back deleter (add to ProcCall)
2289123040 {
2289223041 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2289323042 // copy mutable arguments back from call to add
22894- label = 1836LLU; // continue to roll stack
23043+ label = 1850LLU; // continue to roll stack
2289523044 break;
2289623045 }
22897- case 1849LLU: // return from add to ProcCall
23046+ case 1863LLU: // return from add to ProcCall
2289823047 {
2289923048 // copy mutable arguments back from call to add
2290023049 // copy back results provided by call to add
22901- stack[base + 28] = stack[base + 35LLU];
23050+ stack[base + 30] = stack[base + 37LLU];
2290223051 printf("%s", "\n stack[base + ");
2290323052 // call printnr from ProcCall
22904- stack[base + 32LLU] = 1850LLU/*throw to this address*/;
22905- stack[base + 33LLU] = base;
22906- stack[base + 34LLU] = 1851LLU;
23053+ stack[base + 34LLU] = 1864LLU/*throw to this address*/;
23054+ stack[base + 35LLU] = base;
23055+ stack[base + 36LLU] = 1865LLU;
2290723056 // arguments for call to printnr
22908- stack[base + 35LLU] = stack[base + 28]/*sum*/;
23057+ stack[base + 37LLU] = stack[base + 30]/*sum*/;
2290923058 // set stack-base & callee-address
22910- base += 35LLU;
23059+ base += 37LLU;
2291123060 label = 18446744073709551590LLU; // printnr
2291223061 break;
2291323062 }
22914- case 1850LLU: // copy-back deleter (printnr to ProcCall)
23063+ case 1864LLU: // copy-back deleter (printnr to ProcCall)
2291523064 {
2291623065 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2291723066 // copy mutable arguments back from call to printnr
22918- label = 1836LLU; // continue to roll stack
23067+ label = 1850LLU; // continue to roll stack
2291923068 break;
2292023069 }
22921- case 1851LLU: // return from printnr to ProcCall
23070+ case 1865LLU: // return from printnr to ProcCall
2292223071 {
2292323072 // copy mutable arguments back from call to printnr
2292423073 printf("%s", "LLU] = ");
2292523074 // call printnr from ProcCall
22926- stack[base + 32LLU] = 1852LLU/*throw to this address*/;
22927- stack[base + 33LLU] = base;
22928- stack[base + 34LLU] = 1853LLU;
23075+ stack[base + 34LLU] = 1866LLU/*throw to this address*/;
23076+ stack[base + 35LLU] = base;
23077+ stack[base + 36LLU] = 1867LLU;
2292923078 // arguments for call to printnr
22930- stack[base + 35LLU] = stack[base + 31]/*labelfail*/;
23079+ stack[base + 37LLU] = stack[base + 33]/*labelfail*/;
2293123080 // set stack-base & callee-address
22932- base += 35LLU;
23081+ base += 37LLU;
2293323082 label = 18446744073709551590LLU; // printnr
2293423083 break;
2293523084 }
22936- case 1852LLU: // copy-back deleter (printnr to ProcCall)
23085+ case 1866LLU: // copy-back deleter (printnr to ProcCall)
2293723086 {
2293823087 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2293923088 // copy mutable arguments back from call to printnr
22940- label = 1836LLU; // continue to roll stack
23089+ label = 1850LLU; // continue to roll stack
2294123090 break;
2294223091 }
22943- case 1853LLU: // return from printnr to ProcCall
23092+ case 1867LLU: // return from printnr to ProcCall
2294423093 {
2294523094 // copy mutable arguments back from call to printnr
2294623095 printf("%s", "LLU/*throw to this address*/;");
22947- stack[base + 28]/*sum*/ = 0;
23096+ stack[base + 30]/*sum*/ = 0;
2294823097 // call add from ProcCall
22949- stack[base + 32LLU] = 1854LLU/*throw to this address*/;
22950- stack[base + 33LLU] = base;
22951- stack[base + 34LLU] = 1855LLU;
23098+ stack[base + 34LLU] = 1868LLU/*throw to this address*/;
23099+ stack[base + 35LLU] = base;
23100+ stack[base + 36LLU] = 1869LLU;
2295223101 // arguments for call to add
22953- stack[base + 36LLU] = stack[base + 4]/*offset*/;
22954- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23102+ stack[base + 38LLU] = stack[base + 4]/*offset*/;
23103+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2295523104 // set stack-base & callee-address
22956- base += 35LLU;
23105+ base += 37LLU;
2295723106 label = 18446744073709551605LLU; // add
2295823107 break;
2295923108 }
22960- case 1854LLU: // copy-back deleter (add to ProcCall)
23109+ case 1868LLU: // copy-back deleter (add to ProcCall)
2296123110 {
2296223111 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2296323112 // copy mutable arguments back from call to add
22964- label = 1836LLU; // continue to roll stack
23113+ label = 1850LLU; // continue to roll stack
2296523114 break;
2296623115 }
22967- case 1855LLU: // return from add to ProcCall
23116+ case 1869LLU: // return from add to ProcCall
2296823117 {
2296923118 // copy mutable arguments back from call to add
2297023119 // copy back results provided by call to add
22971- stack[base + 28] = stack[base + 35LLU];
23120+ stack[base + 30] = stack[base + 37LLU];
2297223121 // call add from ProcCall
22973- stack[base + 32LLU] = 1856LLU/*throw to this address*/;
22974- stack[base + 33LLU] = base;
22975- stack[base + 34LLU] = 1857LLU;
23122+ stack[base + 34LLU] = 1870LLU/*throw to this address*/;
23123+ stack[base + 35LLU] = base;
23124+ stack[base + 36LLU] = 1871LLU;
2297623125 // arguments for call to add
22977- stack[base + 36LLU] = stack[base + 9]/*fnrescount*/;
22978- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23126+ stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
23127+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2297923128 // set stack-base & callee-address
22980- base += 35LLU;
23129+ base += 37LLU;
2298123130 label = 18446744073709551605LLU; // add
2298223131 break;
2298323132 }
22984- case 1856LLU: // copy-back deleter (add to ProcCall)
23133+ case 1870LLU: // copy-back deleter (add to ProcCall)
2298523134 {
2298623135 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2298723136 // copy mutable arguments back from call to add
22988- label = 1836LLU; // continue to roll stack
23137+ label = 1850LLU; // continue to roll stack
2298923138 break;
2299023139 }
22991- case 1857LLU: // return from add to ProcCall
23140+ case 1871LLU: // return from add to ProcCall
2299223141 {
2299323142 // copy mutable arguments back from call to add
2299423143 // copy back results provided by call to add
22995- stack[base + 28] = stack[base + 35LLU];
23144+ stack[base + 30] = stack[base + 37LLU];
2299623145 // call add from ProcCall
22997- stack[base + 32LLU] = 1858LLU/*throw to this address*/;
22998- stack[base + 33LLU] = base;
22999- stack[base + 34LLU] = 1859LLU;
23146+ stack[base + 34LLU] = 1872LLU/*throw to this address*/;
23147+ stack[base + 35LLU] = base;
23148+ stack[base + 36LLU] = 1873LLU;
2300023149 // arguments for call to add
23001- stack[base + 36LLU] = stack[base + 10]/*fnargcount*/;
23002- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23150+ stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
23151+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2300323152 // set stack-base & callee-address
23004- base += 35LLU;
23153+ base += 37LLU;
2300523154 label = 18446744073709551605LLU; // add
2300623155 break;
2300723156 }
23008- case 1858LLU: // copy-back deleter (add to ProcCall)
23157+ case 1872LLU: // copy-back deleter (add to ProcCall)
2300923158 {
2301023159 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2301123160 // copy mutable arguments back from call to add
23012- label = 1836LLU; // continue to roll stack
23161+ label = 1850LLU; // continue to roll stack
2301323162 break;
2301423163 }
23015- case 1859LLU: // return from add to ProcCall
23164+ case 1873LLU: // return from add to ProcCall
2301623165 {
2301723166 // copy mutable arguments back from call to add
2301823167 // copy back results provided by call to add
23019- stack[base + 28] = stack[base + 35LLU];
23168+ stack[base + 30] = stack[base + 37LLU];
2302023169 // call add from ProcCall
23021- stack[base + 32LLU] = 1860LLU/*throw to this address*/;
23022- stack[base + 33LLU] = base;
23023- stack[base + 34LLU] = 1861LLU;
23170+ stack[base + 34LLU] = 1874LLU/*throw to this address*/;
23171+ stack[base + 35LLU] = base;
23172+ stack[base + 36LLU] = 1875LLU;
2302423173 // arguments for call to add
23025- stack[base + 36LLU] = 1LLU;
23026- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23174+ stack[base + 38LLU] = 1LLU;
23175+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2302723176 // set stack-base & callee-address
23028- base += 35LLU;
23177+ base += 37LLU;
2302923178 label = 18446744073709551605LLU; // add
2303023179 break;
2303123180 }
23032- case 1860LLU: // copy-back deleter (add to ProcCall)
23181+ case 1874LLU: // copy-back deleter (add to ProcCall)
2303323182 {
2303423183 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2303523184 // copy mutable arguments back from call to add
23036- label = 1836LLU; // continue to roll stack
23185+ label = 1850LLU; // continue to roll stack
2303723186 break;
2303823187 }
23039- case 1861LLU: // return from add to ProcCall
23188+ case 1875LLU: // return from add to ProcCall
2304023189 {
2304123190 // copy mutable arguments back from call to add
2304223191 // copy back results provided by call to add
23043- stack[base + 28] = stack[base + 35LLU];
23192+ stack[base + 30] = stack[base + 37LLU];
2304423193 printf("%s", "\n stack[base + ");
2304523194 // call printnr from ProcCall
23046- stack[base + 32LLU] = 1862LLU/*throw to this address*/;
23047- stack[base + 33LLU] = base;
23048- stack[base + 34LLU] = 1863LLU;
23195+ stack[base + 34LLU] = 1876LLU/*throw to this address*/;
23196+ stack[base + 35LLU] = base;
23197+ stack[base + 36LLU] = 1877LLU;
2304923198 // arguments for call to printnr
23050- stack[base + 35LLU] = stack[base + 28]/*sum*/;
23199+ stack[base + 37LLU] = stack[base + 30]/*sum*/;
2305123200 // set stack-base & callee-address
23052- base += 35LLU;
23201+ base += 37LLU;
2305323202 label = 18446744073709551590LLU; // printnr
2305423203 break;
2305523204 }
23056- case 1862LLU: // copy-back deleter (printnr to ProcCall)
23205+ case 1876LLU: // copy-back deleter (printnr to ProcCall)
2305723206 {
2305823207 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2305923208 // copy mutable arguments back from call to printnr
23060- label = 1836LLU; // continue to roll stack
23209+ label = 1850LLU; // continue to roll stack
2306123210 break;
2306223211 }
23063- case 1863LLU: // return from printnr to ProcCall
23212+ case 1877LLU: // return from printnr to ProcCall
2306423213 {
2306523214 // copy mutable arguments back from call to printnr
2306623215 printf("%s", "LLU] = base;");
23067- stack[base + 28]/*sum*/ = 0;
23216+ stack[base + 30]/*sum*/ = 0;
2306823217 // call add from ProcCall
23069- stack[base + 32LLU] = 1864LLU/*throw to this address*/;
23070- stack[base + 33LLU] = base;
23071- stack[base + 34LLU] = 1865LLU;
23218+ stack[base + 34LLU] = 1878LLU/*throw to this address*/;
23219+ stack[base + 35LLU] = base;
23220+ stack[base + 36LLU] = 1879LLU;
2307223221 // arguments for call to add
23073- stack[base + 36LLU] = stack[base + 4]/*offset*/;
23074- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23222+ stack[base + 38LLU] = stack[base + 4]/*offset*/;
23223+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2307523224 // set stack-base & callee-address
23076- base += 35LLU;
23225+ base += 37LLU;
2307723226 label = 18446744073709551605LLU; // add
2307823227 break;
2307923228 }
23080- case 1864LLU: // copy-back deleter (add to ProcCall)
23229+ case 1878LLU: // copy-back deleter (add to ProcCall)
2308123230 {
2308223231 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2308323232 // copy mutable arguments back from call to add
23084- label = 1836LLU; // continue to roll stack
23233+ label = 1850LLU; // continue to roll stack
2308523234 break;
2308623235 }
23087- case 1865LLU: // return from add to ProcCall
23236+ case 1879LLU: // return from add to ProcCall
2308823237 {
2308923238 // copy mutable arguments back from call to add
2309023239 // copy back results provided by call to add
23091- stack[base + 28] = stack[base + 35LLU];
23240+ stack[base + 30] = stack[base + 37LLU];
2309223241 // call add from ProcCall
23093- stack[base + 32LLU] = 1866LLU/*throw to this address*/;
23094- stack[base + 33LLU] = base;
23095- stack[base + 34LLU] = 1867LLU;
23242+ stack[base + 34LLU] = 1880LLU/*throw to this address*/;
23243+ stack[base + 35LLU] = base;
23244+ stack[base + 36LLU] = 1881LLU;
2309623245 // arguments for call to add
23097- stack[base + 36LLU] = stack[base + 9]/*fnrescount*/;
23098- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23246+ stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
23247+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2309923248 // set stack-base & callee-address
23100- base += 35LLU;
23249+ base += 37LLU;
2310123250 label = 18446744073709551605LLU; // add
2310223251 break;
2310323252 }
23104- case 1866LLU: // copy-back deleter (add to ProcCall)
23253+ case 1880LLU: // copy-back deleter (add to ProcCall)
2310523254 {
2310623255 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2310723256 // copy mutable arguments back from call to add
23108- label = 1836LLU; // continue to roll stack
23257+ label = 1850LLU; // continue to roll stack
2310923258 break;
2311023259 }
23111- case 1867LLU: // return from add to ProcCall
23260+ case 1881LLU: // return from add to ProcCall
2311223261 {
2311323262 // copy mutable arguments back from call to add
2311423263 // copy back results provided by call to add
23115- stack[base + 28] = stack[base + 35LLU];
23264+ stack[base + 30] = stack[base + 37LLU];
2311623265 // call add from ProcCall
23117- stack[base + 32LLU] = 1868LLU/*throw to this address*/;
23118- stack[base + 33LLU] = base;
23119- stack[base + 34LLU] = 1869LLU;
23266+ stack[base + 34LLU] = 1882LLU/*throw to this address*/;
23267+ stack[base + 35LLU] = base;
23268+ stack[base + 36LLU] = 1883LLU;
2312023269 // arguments for call to add
23121- stack[base + 36LLU] = stack[base + 10]/*fnargcount*/;
23122- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23270+ stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
23271+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2312323272 // set stack-base & callee-address
23124- base += 35LLU;
23273+ base += 37LLU;
2312523274 label = 18446744073709551605LLU; // add
2312623275 break;
2312723276 }
23128- case 1868LLU: // copy-back deleter (add to ProcCall)
23277+ case 1882LLU: // copy-back deleter (add to ProcCall)
2312923278 {
2313023279 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2313123280 // copy mutable arguments back from call to add
23132- label = 1836LLU; // continue to roll stack
23281+ label = 1850LLU; // continue to roll stack
2313323282 break;
2313423283 }
23135- case 1869LLU: // return from add to ProcCall
23284+ case 1883LLU: // return from add to ProcCall
2313623285 {
2313723286 // copy mutable arguments back from call to add
2313823287 // copy back results provided by call to add
23139- stack[base + 28] = stack[base + 35LLU];
23288+ stack[base + 30] = stack[base + 37LLU];
2314023289 // call add from ProcCall
23141- stack[base + 32LLU] = 1870LLU/*throw to this address*/;
23142- stack[base + 33LLU] = base;
23143- stack[base + 34LLU] = 1871LLU;
23290+ stack[base + 34LLU] = 1884LLU/*throw to this address*/;
23291+ stack[base + 35LLU] = base;
23292+ stack[base + 36LLU] = 1885LLU;
2314423293 // arguments for call to add
23145- stack[base + 36LLU] = 2LLU;
23146- stack[base + 37LLU] = stack[base + 28]/*sum*/;
23294+ stack[base + 38LLU] = 2LLU;
23295+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2314723296 // set stack-base & callee-address
23148- base += 35LLU;
23297+ base += 37LLU;
2314923298 label = 18446744073709551605LLU; // add
2315023299 break;
2315123300 }
23152- case 1870LLU: // copy-back deleter (add to ProcCall)
23301+ case 1884LLU: // copy-back deleter (add to ProcCall)
2315323302 {
2315423303 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2315523304 // copy mutable arguments back from call to add
23156- label = 1836LLU; // continue to roll stack
23305+ label = 1850LLU; // continue to roll stack
2315723306 break;
2315823307 }
23159- case 1871LLU: // return from add to ProcCall
23308+ case 1885LLU: // return from add to ProcCall
2316023309 {
2316123310 // copy mutable arguments back from call to add
2316223311 // copy back results provided by call to add
23163- stack[base + 28] = stack[base + 35LLU];
23312+ stack[base + 30] = stack[base + 37LLU];
2316423313 // call add from ProcCall
23165- stack[base + 32LLU] = 1872LLU/*throw to this address*/;
23166- stack[base + 33LLU] = base;
23167- stack[base + 34LLU] = 1873LLU;
23314+ stack[base + 34LLU] = 1886LLU/*throw to this address*/;
23315+ stack[base + 35LLU] = base;
23316+ stack[base + 36LLU] = 1887LLU;
2316823317 // arguments for call to add
23169- stack[base + 36LLU] = 1LLU;
23170- stack[base + 37LLU] = stack[base + 16]/*label*/;
23318+ stack[base + 38LLU] = 1LLU;
23319+ stack[base + 39LLU] = stack[base + 17]/*label*/;
2317123320 // set stack-base & callee-address
23172- base += 35LLU;
23321+ base += 37LLU;
2317323322 label = 18446744073709551605LLU; // add
2317423323 break;
2317523324 }
23176- case 1872LLU: // copy-back deleter (add to ProcCall)
23325+ case 1886LLU: // copy-back deleter (add to ProcCall)
2317723326 {
2317823327 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2317923328 // copy mutable arguments back from call to add
23180- label = 1836LLU; // continue to roll stack
23329+ label = 1850LLU; // continue to roll stack
2318123330 break;
2318223331 }
23183- case 1873LLU: // return from add to ProcCall
23332+ case 1887LLU: // return from add to ProcCall
2318423333 {
2318523334 // copy mutable arguments back from call to add
2318623335 // copy back results provided by call to add
23187- stack[base + 16] = stack[base + 35LLU];
23336+ stack[base + 17] = stack[base + 37LLU];
2318823337 printf("%s", "\n stack[base + ");
2318923338 // call printnr from ProcCall
23190- stack[base + 32LLU] = 1874LLU/*throw to this address*/;
23191- stack[base + 33LLU] = base;
23192- stack[base + 34LLU] = 1875LLU;
23339+ stack[base + 34LLU] = 1888LLU/*throw to this address*/;
23340+ stack[base + 35LLU] = base;
23341+ stack[base + 36LLU] = 1889LLU;
2319323342 // arguments for call to printnr
23194- stack[base + 35LLU] = stack[base + 28]/*sum*/;
23343+ stack[base + 37LLU] = stack[base + 30]/*sum*/;
2319523344 // set stack-base & callee-address
23196- base += 35LLU;
23345+ base += 37LLU;
2319723346 label = 18446744073709551590LLU; // printnr
2319823347 break;
2319923348 }
23200- case 1874LLU: // copy-back deleter (printnr to ProcCall)
23349+ case 1888LLU: // copy-back deleter (printnr to ProcCall)
2320123350 {
2320223351 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2320323352 // copy mutable arguments back from call to printnr
23204- label = 1836LLU; // continue to roll stack
23353+ label = 1850LLU; // continue to roll stack
2320523354 break;
2320623355 }
23207- case 1875LLU: // return from printnr to ProcCall
23356+ case 1889LLU: // return from printnr to ProcCall
2320823357 {
2320923358 // copy mutable arguments back from call to printnr
2321023359 printf("%s", "LLU] = ");
2321123360 // call printnr from ProcCall
23212- stack[base + 32LLU] = 1876LLU/*throw to this address*/;
23213- stack[base + 33LLU] = base;
23214- stack[base + 34LLU] = 1877LLU;
23361+ stack[base + 34LLU] = 1890LLU/*throw to this address*/;
23362+ stack[base + 35LLU] = base;
23363+ stack[base + 36LLU] = 1891LLU;
2321523364 // arguments for call to printnr
23216- stack[base + 35LLU] = stack[base + 16]/*label*/;
23365+ stack[base + 37LLU] = stack[base + 17]/*label*/;
2321723366 // set stack-base & callee-address
23218- base += 35LLU;
23367+ base += 37LLU;
2321923368 label = 18446744073709551590LLU; // printnr
2322023369 break;
2322123370 }
23222- case 1876LLU: // copy-back deleter (printnr to ProcCall)
23371+ case 1890LLU: // copy-back deleter (printnr to ProcCall)
2322323372 {
2322423373 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2322523374 // copy mutable arguments back from call to printnr
23226- label = 1836LLU; // continue to roll stack
23375+ label = 1850LLU; // continue to roll stack
2322723376 break;
2322823377 }
23229- case 1877LLU: // return from printnr to ProcCall
23378+ case 1891LLU: // return from printnr to ProcCall
2323023379 {
2323123380 // copy mutable arguments back from call to printnr
2323223381 printf("%s", "LLU;");
23233- stack[base + 29]/*n*/ = stack[base + 27]/*ceargcount*/;
23382+ stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
2323423383 printf("%s", "\n // arguments for call to ");
2323523384 // call printid from ProcCall
23236- stack[base + 32LLU] = 1878LLU/*throw to this address*/;
23237- stack[base + 33LLU] = base;
23238- stack[base + 34LLU] = 1879LLU;
23385+ stack[base + 34LLU] = 1892LLU/*throw to this address*/;
23386+ stack[base + 35LLU] = base;
23387+ stack[base + 36LLU] = 1893LLU;
2323923388 // arguments for call to printid
23240- stack[base + 35LLU] = stack[base + 23]/*ceid*/;
23389+ stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2324123390 // set stack-base & callee-address
23242- base += 35LLU;
23391+ base += 37LLU;
2324323392 label = 18446744073709551587LLU; // printid
2324423393 break;
2324523394 }
23246- case 1878LLU: // copy-back deleter (printid to ProcCall)
23395+ case 1892LLU: // copy-back deleter (printid to ProcCall)
2324723396 {
2324823397 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2324923398 // copy mutable arguments back from call to printid
23250- label = 1836LLU; // continue to roll stack
23399+ label = 1850LLU; // continue to roll stack
2325123400 break;
2325223401 }
23253- case 1879LLU: // return from printid to ProcCall
23402+ case 1893LLU: // return from printid to ProcCall
2325423403 {
2325523404 // copy mutable arguments back from call to printid
23256- flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 32]);
23257- label = 1880LLU; // start to repeat
23405+ flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 34]);
23406+ label = 1894LLU; // start to repeat
2325823407 break;
2325923408 }
23260- case 1880LLU: // repeat from here
23409+ case 1894LLU: // repeat from here
2326123410 {
23262- if(!stack[base + 32])
23411+ if(!stack[base + 34])
2326323412 {
23264- label = 1881LLU; // break loop
23413+ label = 1895LLU; // break loop
2326523414 break;
2326623415 }
2326723416
2326823417 // loop body
23269- stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 32]))->data);
23270- stack[base + 34]/*previous*/ = stack[base + 32];
23271- stack[base + 32] = (uint64_t)(((const struct listnode *)(stack[base + 32]))->next);
23418+ stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data);
23419+ stack[base + 36]/*previous*/ = stack[base + 34];
23420+ stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
2327223421 // call sub from ProcCall
23273- stack[base + 35LLU] = 1882LLU/*throw to this address*/;
23274- stack[base + 36LLU] = base;
23275- stack[base + 37LLU] = 1883LLU;
23422+ stack[base + 37LLU] = 1896LLU/*throw to this address*/;
23423+ stack[base + 38LLU] = base;
23424+ stack[base + 39LLU] = 1897LLU;
2327623425 // arguments for call to sub
23277- stack[base + 39LLU] = stack[base + 27]/*ceargcount*/;
23278- stack[base + 40LLU] = stack[base + 29]/*n*/;
23426+ stack[base + 41LLU] = stack[base + 29]/*ceargcount*/;
23427+ stack[base + 42LLU] = stack[base + 31]/*n*/;
2327923428 // set stack-base & callee-address
23280- base += 38LLU;
23429+ base += 40LLU;
2328123430 label = 18446744073709551604LLU; // sub
2328223431 break;
2328323432 }
23284- case 1882LLU: // copy-back deleter (sub to ProcCall)
23433+ case 1896LLU: // copy-back deleter (sub to ProcCall)
2328523434 {
2328623435 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2328723436 // copy mutable arguments back from call to sub
23288- label = 1836LLU; // continue to roll stack
23437+ label = 1850LLU; // continue to roll stack
2328923438 break;
2329023439 }
23291- case 1883LLU: // return from sub to ProcCall
23440+ case 1897LLU: // return from sub to ProcCall
2329223441 {
2329323442 // copy mutable arguments back from call to sub
2329423443 // copy back results provided by call to sub
23295- stack[base + 30] = stack[base + 38LLU];
23444+ stack[base + 32] = stack[base + 40LLU];
2329623445 // call sub from ProcCall
23297- stack[base + 35LLU] = 1884LLU/*throw to this address*/;
23298- stack[base + 36LLU] = base;
23299- stack[base + 37LLU] = 1885LLU;
23446+ stack[base + 37LLU] = 1898LLU/*throw to this address*/;
23447+ stack[base + 38LLU] = base;
23448+ stack[base + 39LLU] = 1899LLU;
2330023449 // arguments for call to sub
23301- stack[base + 39LLU] = stack[base + 29]/*n*/;
23302- stack[base + 40LLU] = 1LLU;
23450+ stack[base + 41LLU] = stack[base + 31]/*n*/;
23451+ stack[base + 42LLU] = 1LLU;
2330323452 // set stack-base & callee-address
23304- base += 38LLU;
23453+ base += 40LLU;
2330523454 label = 18446744073709551604LLU; // sub
2330623455 break;
2330723456 }
23308- case 1884LLU: // copy-back deleter (sub to ProcCall)
23457+ case 1898LLU: // copy-back deleter (sub to ProcCall)
2330923458 {
2331023459 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2331123460 // copy mutable arguments back from call to sub
23312- label = 1836LLU; // continue to roll stack
23461+ label = 1850LLU; // continue to roll stack
2331323462 break;
2331423463 }
23315- case 1885LLU: // return from sub to ProcCall
23464+ case 1899LLU: // return from sub to ProcCall
2331623465 {
2331723466 // copy mutable arguments back from call to sub
2331823467 // copy back results provided by call to sub
23319- stack[base + 29] = stack[base + 38LLU];
23320- if(!stack[base + 30]/*index*/)
23468+ stack[base + 31] = stack[base + 40LLU];
23469+ if(!stack[base + 32]/*index*/)
2332123470 {
23322- label = 1886LLU; // jump to alternative
23471+ label = 1900LLU; // jump to alternative
2332323472 break;
2332423473 }
2332523474
2332623475 // consequent
2332723476 // call matchsym from ProcCall
23328- stack[base + 35LLU] = 1888LLU/*throw to this address*/;
23329- stack[base + 36LLU] = base;
23330- stack[base + 37LLU] = 1889LLU;
23477+ stack[base + 37LLU] = 1902LLU/*throw to this address*/;
23478+ stack[base + 38LLU] = base;
23479+ stack[base + 39LLU] = 1903LLU;
2333123480 // arguments for call to matchsym
23332- stack[base + 38LLU] = stack[base + 7]/*fnid*/;
23333- stack[base + 39LLU] = 44LLU;
23334- stack[base + 40LLU] = stack[base + 13]/*lookahead*/;
23481+ stack[base + 40LLU] = stack[base + 8]/*fnid*/;
23482+ stack[base + 41LLU] = 44LLU;
23483+ stack[base + 42LLU] = stack[base + 14]/*lookahead*/;
2333523484 // set stack-base & callee-address
23336- base += 38LLU;
23485+ base += 40LLU;
2333723486 label = 211LLU; // matchsym
2333823487 break;
2333923488 }
23340- case 1888LLU: // copy-back deleter (matchsym to ProcCall)
23489+ case 1902LLU: // copy-back deleter (matchsym to ProcCall)
2334123490 {
2334223491 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
2334323492 // copy mutable arguments back from call to matchsym
23344- stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
23345- label = 1836LLU; // continue to roll stack
23493+ stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
23494+ label = 1850LLU; // continue to roll stack
2334623495 break;
2334723496 }
23348- case 1889LLU: // return from matchsym to ProcCall
23497+ case 1903LLU: // return from matchsym to ProcCall
2334923498 {
2335023499 // copy mutable arguments back from call to matchsym
23351- stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
23352- label = 1887LLU; // consequent complete
23500+ stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
23501+ label = 1901LLU; // consequent complete
2335323502 break;
2335423503 }
23355- case 1886LLU: // alternative
23504+ case 1900LLU: // alternative
2335623505 {
23357- label = 1887LLU; // alternative complete
23506+ label = 1901LLU; // alternative complete
2335823507 break;
2335923508 }
23360- case 1887LLU: // completed if-then-else
23509+ case 1901LLU: // completed if-then-else
2336123510 {
23362- stack[base + 28]/*sum*/ = 0;
23511+ stack[base + 30]/*sum*/ = 0;
2336323512 // call add from ProcCall
23364- stack[base + 35LLU] = 1890LLU/*throw to this address*/;
23365- stack[base + 36LLU] = base;
23366- stack[base + 37LLU] = 1891LLU;
23513+ stack[base + 37LLU] = 1904LLU/*throw to this address*/;
23514+ stack[base + 38LLU] = base;
23515+ stack[base + 39LLU] = 1905LLU;
2336723516 // arguments for call to add
23368- stack[base + 39LLU] = stack[base + 4]/*offset*/;
23369- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23517+ stack[base + 41LLU] = stack[base + 4]/*offset*/;
23518+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2337023519 // set stack-base & callee-address
23371- base += 38LLU;
23520+ base += 40LLU;
2337223521 label = 18446744073709551605LLU; // add
2337323522 break;
2337423523 }
23375- case 1890LLU: // copy-back deleter (add to ProcCall)
23524+ case 1904LLU: // copy-back deleter (add to ProcCall)
2337623525 {
2337723526 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2337823527 // copy mutable arguments back from call to add
23379- label = 1836LLU; // continue to roll stack
23528+ label = 1850LLU; // continue to roll stack
2338023529 break;
2338123530 }
23382- case 1891LLU: // return from add to ProcCall
23531+ case 1905LLU: // return from add to ProcCall
2338323532 {
2338423533 // copy mutable arguments back from call to add
2338523534 // copy back results provided by call to add
23386- stack[base + 28] = stack[base + 38LLU];
23535+ stack[base + 30] = stack[base + 40LLU];
2338723536 // call add from ProcCall
23388- stack[base + 35LLU] = 1892LLU/*throw to this address*/;
23389- stack[base + 36LLU] = base;
23390- stack[base + 37LLU] = 1893LLU;
23537+ stack[base + 37LLU] = 1906LLU/*throw to this address*/;
23538+ stack[base + 38LLU] = base;
23539+ stack[base + 39LLU] = 1907LLU;
2339123540 // arguments for call to add
23392- stack[base + 39LLU] = 3LLU;
23393- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23541+ stack[base + 41LLU] = 3LLU;
23542+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2339423543 // set stack-base & callee-address
23395- base += 38LLU;
23544+ base += 40LLU;
2339623545 label = 18446744073709551605LLU; // add
2339723546 break;
2339823547 }
23399- case 1892LLU: // copy-back deleter (add to ProcCall)
23548+ case 1906LLU: // copy-back deleter (add to ProcCall)
2340023549 {
2340123550 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2340223551 // copy mutable arguments back from call to add
23403- label = 1836LLU; // continue to roll stack
23552+ label = 1850LLU; // continue to roll stack
2340423553 break;
2340523554 }
23406- case 1893LLU: // return from add to ProcCall
23555+ case 1907LLU: // return from add to ProcCall
2340723556 {
2340823557 // copy mutable arguments back from call to add
2340923558 // copy back results provided by call to add
23410- stack[base + 28] = stack[base + 38LLU];
23559+ stack[base + 30] = stack[base + 40LLU];
2341123560 // call add from ProcCall
23412- stack[base + 35LLU] = 1894LLU/*throw to this address*/;
23413- stack[base + 36LLU] = base;
23414- stack[base + 37LLU] = 1895LLU;
23561+ stack[base + 37LLU] = 1908LLU/*throw to this address*/;
23562+ stack[base + 38LLU] = base;
23563+ stack[base + 39LLU] = 1909LLU;
2341523564 // arguments for call to add
23416- stack[base + 39LLU] = stack[base + 9]/*fnrescount*/;
23417- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23565+ stack[base + 41LLU] = stack[base + 10]/*fnrescount*/;
23566+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2341823567 // set stack-base & callee-address
23419- base += 38LLU;
23568+ base += 40LLU;
2342023569 label = 18446744073709551605LLU; // add
2342123570 break;
2342223571 }
23423- case 1894LLU: // copy-back deleter (add to ProcCall)
23572+ case 1908LLU: // copy-back deleter (add to ProcCall)
2342423573 {
2342523574 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2342623575 // copy mutable arguments back from call to add
23427- label = 1836LLU; // continue to roll stack
23576+ label = 1850LLU; // continue to roll stack
2342823577 break;
2342923578 }
23430- case 1895LLU: // return from add to ProcCall
23579+ case 1909LLU: // return from add to ProcCall
2343123580 {
2343223581 // copy mutable arguments back from call to add
2343323582 // copy back results provided by call to add
23434- stack[base + 28] = stack[base + 38LLU];
23583+ stack[base + 30] = stack[base + 40LLU];
2343523584 // call add from ProcCall
23436- stack[base + 35LLU] = 1896LLU/*throw to this address*/;
23437- stack[base + 36LLU] = base;
23438- stack[base + 37LLU] = 1897LLU;
23585+ stack[base + 37LLU] = 1910LLU/*throw to this address*/;
23586+ stack[base + 38LLU] = base;
23587+ stack[base + 39LLU] = 1911LLU;
2343923588 // arguments for call to add
23440- stack[base + 39LLU] = stack[base + 10]/*fnargcount*/;
23441- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23589+ stack[base + 41LLU] = stack[base + 11]/*fnargcount*/;
23590+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2344223591 // set stack-base & callee-address
23443- base += 38LLU;
23592+ base += 40LLU;
2344423593 label = 18446744073709551605LLU; // add
2344523594 break;
2344623595 }
23447- case 1896LLU: // copy-back deleter (add to ProcCall)
23596+ case 1910LLU: // copy-back deleter (add to ProcCall)
2344823597 {
2344923598 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2345023599 // copy mutable arguments back from call to add
23451- label = 1836LLU; // continue to roll stack
23600+ label = 1850LLU; // continue to roll stack
2345223601 break;
2345323602 }
23454- case 1897LLU: // return from add to ProcCall
23603+ case 1911LLU: // return from add to ProcCall
2345523604 {
2345623605 // copy mutable arguments back from call to add
2345723606 // copy back results provided by call to add
23458- stack[base + 28] = stack[base + 38LLU];
23607+ stack[base + 30] = stack[base + 40LLU];
2345923608 // call add from ProcCall
23460- stack[base + 35LLU] = 1898LLU/*throw to this address*/;
23461- stack[base + 36LLU] = base;
23462- stack[base + 37LLU] = 1899LLU;
23609+ stack[base + 37LLU] = 1912LLU/*throw to this address*/;
23610+ stack[base + 38LLU] = base;
23611+ stack[base + 39LLU] = 1913LLU;
2346323612 // arguments for call to add
23464- stack[base + 39LLU] = stack[base + 26]/*cerescount*/;
23465- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23613+ stack[base + 41LLU] = stack[base + 28]/*cerescount*/;
23614+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2346623615 // set stack-base & callee-address
23467- base += 38LLU;
23616+ base += 40LLU;
2346823617 label = 18446744073709551605LLU; // add
2346923618 break;
2347023619 }
23471- case 1898LLU: // copy-back deleter (add to ProcCall)
23620+ case 1912LLU: // copy-back deleter (add to ProcCall)
2347223621 {
2347323622 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2347423623 // copy mutable arguments back from call to add
23475- label = 1836LLU; // continue to roll stack
23624+ label = 1850LLU; // continue to roll stack
2347623625 break;
2347723626 }
23478- case 1899LLU: // return from add to ProcCall
23627+ case 1913LLU: // return from add to ProcCall
2347923628 {
2348023629 // copy mutable arguments back from call to add
2348123630 // copy back results provided by call to add
23482- stack[base + 28] = stack[base + 38LLU];
23631+ stack[base + 30] = stack[base + 40LLU];
2348323632 // call add from ProcCall
23484- stack[base + 35LLU] = 1900LLU/*throw to this address*/;
23485- stack[base + 36LLU] = base;
23486- stack[base + 37LLU] = 1901LLU;
23633+ stack[base + 37LLU] = 1914LLU/*throw to this address*/;
23634+ stack[base + 38LLU] = base;
23635+ stack[base + 39LLU] = 1915LLU;
2348723636 // arguments for call to add
23488- stack[base + 39LLU] = stack[base + 30]/*index*/;
23489- stack[base + 40LLU] = stack[base + 28]/*sum*/;
23637+ stack[base + 41LLU] = stack[base + 32]/*index*/;
23638+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2349023639 // set stack-base & callee-address
23491- base += 38LLU;
23640+ base += 40LLU;
2349223641 label = 18446744073709551605LLU; // add
2349323642 break;
2349423643 }
23495- case 1900LLU: // copy-back deleter (add to ProcCall)
23644+ case 1914LLU: // copy-back deleter (add to ProcCall)
2349623645 {
2349723646 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2349823647 // copy mutable arguments back from call to add
23499- label = 1836LLU; // continue to roll stack
23648+ label = 1850LLU; // continue to roll stack
2350023649 break;
2350123650 }
23502- case 1901LLU: // return from add to ProcCall
23651+ case 1915LLU: // return from add to ProcCall
2350323652 {
2350423653 // copy mutable arguments back from call to add
2350523654 // copy back results provided by call to add
23506- stack[base + 28] = stack[base + 38LLU];
23655+ stack[base + 30] = stack[base + 40LLU];
2350723656 // call ParseToken from ProcCall
23508- stack[base + 35LLU] = 1902LLU/*throw to this address*/;
23509- stack[base + 36LLU] = base;
23510- stack[base + 37LLU] = 1903LLU;
23657+ stack[base + 37LLU] = 1916LLU/*throw to this address*/;
23658+ stack[base + 38LLU] = base;
23659+ stack[base + 39LLU] = 1917LLU;
2351123660 // arguments for call to ParseToken
23512- stack[base + 40LLU] = stack[base + 13]/*lookahead*/;
23661+ stack[base + 42LLU] = stack[base + 14]/*lookahead*/;
2351323662 // set stack-base & callee-address
23514- base += 38LLU;
23663+ base += 40LLU;
2351523664 label = 3LLU; // ParseToken
2351623665 break;
2351723666 }
23518- case 1902LLU: // copy-back deleter (ParseToken to ProcCall)
23667+ case 1916LLU: // copy-back deleter (ParseToken to ProcCall)
2351923668 {
2352023669 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n");
2352123670 // copy mutable arguments back from call to ParseToken
23522- stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
23523- label = 1836LLU; // continue to roll stack
23671+ stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
23672+ label = 1850LLU; // continue to roll stack
2352423673 break;
2352523674 }
23526- case 1903LLU: // return from ParseToken to ProcCall
23675+ case 1917LLU: // return from ParseToken to ProcCall
2352723676 {
2352823677 // copy mutable arguments back from call to ParseToken
23529- stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
23678+ stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
2353023679 // copy back results provided by call to ParseToken
23531- stack[base + 14] = stack[base + 38LLU];
23532- stack[base + 15] = stack[base + 39LLU];
23680+ stack[base + 15] = stack[base + 40LLU];
23681+ stack[base + 16] = stack[base + 41LLU];
2353323682 // call isncs from ProcCall
23534- stack[base + 35LLU] = 1904LLU/*throw to this address*/;
23535- stack[base + 36LLU] = base;
23536- stack[base + 37LLU] = 1905LLU;
23683+ stack[base + 37LLU] = 1918LLU/*throw to this address*/;
23684+ stack[base + 38LLU] = base;
23685+ stack[base + 39LLU] = 1919LLU;
2353723686 // arguments for call to isncs
23538- stack[base + 39LLU] = stack[base + 14]/*variant*/;
23687+ stack[base + 41LLU] = stack[base + 15]/*variant*/;
2353923688 // set stack-base & callee-address
23540- base += 38LLU;
23689+ base += 40LLU;
2354123690 label = 271LLU; // isncs
2354223691 break;
2354323692 }
23544- case 1904LLU: // copy-back deleter (isncs to ProcCall)
23693+ case 1918LLU: // copy-back deleter (isncs to ProcCall)
2354523694 {
2354623695 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n");
2354723696 // copy mutable arguments back from call to isncs
23548- label = 1836LLU; // continue to roll stack
23697+ label = 1850LLU; // continue to roll stack
2354923698 break;
2355023699 }
23551- case 1905LLU: // return from isncs to ProcCall
23700+ case 1919LLU: // return from isncs to ProcCall
2355223701 {
2355323702 // copy mutable arguments back from call to isncs
2355423703 // copy back results provided by call to isncs
23555- stack[base + 17] = stack[base + 38LLU];
23556- if(!stack[base + 17]/*isequal*/)
23704+ stack[base + 18] = stack[base + 40LLU];
23705+ if(!stack[base + 18]/*isequal*/)
2355723706 {
23558- label = 1906LLU; // jump to alternative
23707+ label = 1920LLU; // jump to alternative
2355923708 break;
2356023709 }
2356123710
2356223711 // consequent
23563- if(/*param*/0 != ((uint64_t *)(stack[base + 33]/*param*/))[0])
23712+ if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
2356423713 {
23565- label = 1909LLU; // jump to alternative
23714+ label = 1923LLU; // jump to alternative
2356623715 break;
2356723716 }
2356823717
23569- /*typeid*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*param*/))[1][0]/*typeid*/;
23570- /*mutable*/stack[base + 36] = ((uint64_t **)(stack[base + 33]/*param*/))[1][1]/*mutable*/;
23718+ /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/;
23719+ /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/;
2357123720
2357223721 // case
23573- if(/*typeid*/0 != ((uint64_t *)(stack[base + 35]/*typeid*/))[0])
23722+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
2357423723 {
23575- label = 1911LLU; // jump to alternative
23724+ label = 1925LLU; // jump to alternative
2357623725 break;
2357723726 }
2357823727
23579- /*expected*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][0]/*type*/;
23580- /*paramname*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][1]/*id*/;
23728+ /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/;
23729+ /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/;
2358123730
2358223731 // case
2358323732 // call mktypename from ProcCall
23584- stack[base + 40LLU] = 1912LLU/*throw to this address*/;
23585- stack[base + 41LLU] = base;
23586- stack[base + 42LLU] = 1913LLU;
23733+ stack[base + 42LLU] = 1926LLU/*throw to this address*/;
23734+ stack[base + 43LLU] = base;
23735+ stack[base + 44LLU] = 1927LLU;
2358723736 // arguments for call to mktypename
23588- stack[base + 44LLU] = 881834713755418624LLU;
23737+ stack[base + 46LLU] = 881834713755418624LLU;
2358923738 // set stack-base & callee-address
23590- base += 43LLU;
23739+ base += 45LLU;
2359123740 label = 299LLU; // mktypename
2359223741 break;
2359323742 }
23594- case 1912LLU: // copy-back deleter (mktypename to ProcCall)
23743+ case 1926LLU: // copy-back deleter (mktypename to ProcCall)
2359523744 {
2359623745 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n");
2359723746 // copy mutable arguments back from call to mktypename
23598- label = 1836LLU; // continue to roll stack
23747+ label = 1850LLU; // continue to roll stack
2359923748 break;
2360023749 }
23601- case 1913LLU: // return from mktypename to ProcCall
23750+ case 1927LLU: // return from mktypename to ProcCall
2360223751 {
2360323752 // copy mutable arguments back from call to mktypename
2360423753 // copy back results provided by call to mktypename
23605- stack[base + 39] = stack[base + 43LLU];
23754+ stack[base + 41] = stack[base + 45LLU];
2360623755 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2360723756 if(!newstack)
2360823757 {
23609- label = 1836LLU; // throw: begin to unroll stack
23758+ label = 1850LLU; // throw: begin to unroll stack
2361023759 break;
2361123760 }
2361223761
@@ -23613,12 +23762,12 @@
2361323762 newstack[15LLU] = 9876543210LLU; // overflow-marker
2361423763 // call equtype from ProcCall
2361523764 newstack[0] = (uint64_t)stack; // backup stack location
23616- newstack[1] = 1914LLU;
23765+ newstack[1] = 1928LLU;
2361723766 newstack[2] = base;
23618- newstack[3] = 1915LLU;
23767+ newstack[3] = 1929LLU;
2361923768 // arguments for call to equtype
23620- newstack[5LLU] = stack[base + 39]/*type*/;
23621- newstack[6LLU] = stack[base + 37]/*expected*/;
23769+ newstack[5LLU] = stack[base + 41]/*type*/;
23770+ newstack[6LLU] = stack[base + 39]/*expected*/;
2362223771 stack = newstack;
2362323772 // set stack-base & callee-address
2362423773 base = 4/*deloffset*/;
@@ -23625,7 +23774,7 @@
2362523774 label = 335LLU; // equtype
2362623775 break;
2362723776 }
23628- case 1914LLU: // copy-back deleter (equtype to ProcCall)
23777+ case 1928LLU: // copy-back deleter (equtype to ProcCall)
2362923778 {
2363023779 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2363123780 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -23637,15 +23786,15 @@
2363723786 }
2363823787 Free(15LLU + 1, sizeof(uint64_t), stack);
2363923788 stack = oldstack;
23640- label = 1836LLU; // continue to unroll stack
23789+ label = 1850LLU; // continue to unroll stack
2364123790 break;
2364223791 }
23643- case 1915LLU: // return from equtype to ProcCall
23792+ case 1929LLU: // return from equtype to ProcCall
2364423793 {
2364523794 uint64_t *oldstack = (uint64_t *)stack[0];
2364623795 // copy mutable arguments back from call to equtype
2364723796 // copy back results provided by call to equtype
23648- oldstack[base + 17] = stack[4LLU];
23797+ oldstack[base + 18] = stack[4LLU];
2364923798 if(stack[15LLU] != 9876543210LLU)
2365023799 {
2365123800 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -23653,82 +23802,82 @@
2365323802 }
2365423803 Free(15LLU + 1, sizeof(uint64_t), stack);
2365523804 stack = oldstack;
23656- if(!stack[base + 17]/*isequal*/)
23805+ if(!stack[base + 18]/*isequal*/)
2365723806 {
23658- label = 1916LLU; // jump to alternative
23807+ label = 1930LLU; // jump to alternative
2365923808 break;
2366023809 }
2366123810
2366223811 // consequent
23663- label = 1917LLU; // consequent complete
23812+ label = 1931LLU; // consequent complete
2366423813 break;
2366523814 }
23666- case 1916LLU: // alternative
23815+ case 1930LLU: // alternative
2366723816 {
2366823817 fprintf(stderr, "%s", "in function ");
2366923818 // call reportid from ProcCall
23670- stack[base + 40LLU] = 1918LLU/*throw to this address*/;
23671- stack[base + 41LLU] = base;
23672- stack[base + 42LLU] = 1919LLU;
23819+ stack[base + 42LLU] = 1932LLU/*throw to this address*/;
23820+ stack[base + 43LLU] = base;
23821+ stack[base + 44LLU] = 1933LLU;
2367323822 // arguments for call to reportid
23674- stack[base + 43LLU] = stack[base + 7]/*fnid*/;
23823+ stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2367523824 // set stack-base & callee-address
23676- base += 43LLU;
23825+ base += 45LLU;
2367723826 label = 18446744073709551586LLU; // reportid
2367823827 break;
2367923828 }
23680- case 1918LLU: // copy-back deleter (reportid to ProcCall)
23829+ case 1932LLU: // copy-back deleter (reportid to ProcCall)
2368123830 {
2368223831 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2368323832 // copy mutable arguments back from call to reportid
23684- label = 1836LLU; // continue to roll stack
23833+ label = 1850LLU; // continue to roll stack
2368523834 break;
2368623835 }
23687- case 1919LLU: // return from reportid to ProcCall
23836+ case 1933LLU: // return from reportid to ProcCall
2368823837 {
2368923838 // copy mutable arguments back from call to reportid
2369023839 fprintf(stderr, "%s", " call to ");
2369123840 // call reportid from ProcCall
23692- stack[base + 40LLU] = 1920LLU/*throw to this address*/;
23693- stack[base + 41LLU] = base;
23694- stack[base + 42LLU] = 1921LLU;
23841+ stack[base + 42LLU] = 1934LLU/*throw to this address*/;
23842+ stack[base + 43LLU] = base;
23843+ stack[base + 44LLU] = 1935LLU;
2369523844 // arguments for call to reportid
23696- stack[base + 43LLU] = stack[base + 23]/*ceid*/;
23845+ stack[base + 45LLU] = stack[base + 24]/*ceid*/;
2369723846 // set stack-base & callee-address
23698- base += 43LLU;
23847+ base += 45LLU;
2369923848 label = 18446744073709551586LLU; // reportid
2370023849 break;
2370123850 }
23702- case 1920LLU: // copy-back deleter (reportid to ProcCall)
23851+ case 1934LLU: // copy-back deleter (reportid to ProcCall)
2370323852 {
2370423853 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2370523854 // copy mutable arguments back from call to reportid
23706- label = 1836LLU; // continue to roll stack
23855+ label = 1850LLU; // continue to roll stack
2370723856 break;
2370823857 }
23709- case 1921LLU: // return from reportid to ProcCall
23858+ case 1935LLU: // return from reportid to ProcCall
2371023859 {
2371123860 // copy mutable arguments back from call to reportid
2371223861 fprintf(stderr, "%s", " at position ");
2371323862 // call reportnr from ProcCall
23714- stack[base + 40LLU] = 1922LLU/*throw to this address*/;
23715- stack[base + 41LLU] = base;
23716- stack[base + 42LLU] = 1923LLU;
23863+ stack[base + 42LLU] = 1936LLU/*throw to this address*/;
23864+ stack[base + 43LLU] = base;
23865+ stack[base + 44LLU] = 1937LLU;
2371723866 // arguments for call to reportnr
23718- stack[base + 43LLU] = stack[base + 30]/*index*/;
23867+ stack[base + 45LLU] = stack[base + 32]/*index*/;
2371923868 // set stack-base & callee-address
23720- base += 43LLU;
23869+ base += 45LLU;
2372123870 label = 18446744073709551589LLU; // reportnr
2372223871 break;
2372323872 }
23724- case 1922LLU: // copy-back deleter (reportnr to ProcCall)
23873+ case 1936LLU: // copy-back deleter (reportnr to ProcCall)
2372523874 {
2372623875 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2372723876 // copy mutable arguments back from call to reportnr
23728- label = 1836LLU; // continue to roll stack
23877+ label = 1850LLU; // continue to roll stack
2372923878 break;
2373023879 }
23731- case 1923LLU: // return from reportnr to ProcCall
23880+ case 1937LLU: // return from reportnr to ProcCall
2373223881 {
2373323882 // copy mutable arguments back from call to reportnr
2373423883 fprintf(stderr, "%s", " expected parameter of type ");
@@ -23735,7 +23884,7 @@
2373523884 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2373623885 if(!newstack)
2373723886 {
23738- label = 1836LLU; // throw: begin to unroll stack
23887+ label = 1850LLU; // throw: begin to unroll stack
2373923888 break;
2374023889 }
2374123890
@@ -23742,11 +23891,11 @@
2374223891 newstack[10LLU] = 9876543210LLU; // overflow-marker
2374323892 // call reporttype from ProcCall
2374423893 newstack[0] = (uint64_t)stack; // backup stack location
23745- newstack[1] = 1924LLU;
23894+ newstack[1] = 1938LLU;
2374623895 newstack[2] = base;
23747- newstack[3] = 1925LLU;
23896+ newstack[3] = 1939LLU;
2374823897 // arguments for call to reporttype
23749- newstack[4LLU] = stack[base + 37]/*expected*/;
23898+ newstack[4LLU] = stack[base + 39]/*expected*/;
2375023899 stack = newstack;
2375123900 // set stack-base & callee-address
2375223901 base = 4/*deloffset*/;
@@ -23753,7 +23902,7 @@
2375323902 label = 313LLU; // reporttype
2375423903 break;
2375523904 }
23756- case 1924LLU: // copy-back deleter (reporttype to ProcCall)
23905+ case 1938LLU: // copy-back deleter (reporttype to ProcCall)
2375723906 {
2375823907 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2375923908 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -23765,10 +23914,10 @@
2376523914 }
2376623915 Free(10LLU + 1, sizeof(uint64_t), stack);
2376723916 stack = oldstack;
23768- label = 1836LLU; // continue to unroll stack
23917+ label = 1850LLU; // continue to unroll stack
2376923918 break;
2377023919 }
23771- case 1925LLU: // return from reporttype to ProcCall
23920+ case 1939LLU: // return from reporttype to ProcCall
2377223921 {
2377323922 uint64_t *oldstack = (uint64_t *)stack[0];
2377423923 // copy mutable arguments back from call to reporttype
@@ -23782,18 +23931,18 @@
2378223931 fprintf(stderr, "%s", " but found constant-argument of type u64");
2378323932 fprintf(stderr, "%s", "\n");
2378423933 exit(-1);
23785- label = 1917LLU; // alternative complete
23934+ label = 1931LLU; // alternative complete
2378623935 break;
2378723936 }
23788- case 1917LLU: // completed if-then-else
23937+ case 1931LLU: // completed if-then-else
2378923938 {
2379023939
23791- uint64_t *newstack = (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4);
23940+ uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
2379223941 // call ~type from ProcCall
2379323942 newstack[0] = (uint64_t)stack; // backup stack location
2379423943 newstack[1] = 1234567890;
2379523944 newstack[2] = base;
23796- newstack[3] = 1926LLU;
23945+ newstack[3] = 1940LLU;
2379723946 stack = newstack;
2379823947 // set stack-base & callee-address
2379923948 base = 4/*deloffset*/;
@@ -23800,27 +23949,27 @@
2380023949 label = 295LLU; // ~type
2380123950 break;
2380223951 }
23803- case 1926LLU: // return from ~type to ProcCall
23952+ case 1940LLU: // return from ~type to ProcCall
2380423953 {
2380523954 stack = (uint64_t *)stack[0];
2380623955 // releasing toplevel container
23807- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4));
23956+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4));
2380823957
23809- ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
23810- ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
23811- label = 1910LLU; // case complete
23958+ ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
23959+ ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23960+ label = 1924LLU; // case complete
2381223961 break;
2381323962 }
23814- case 1911LLU: // try next case
23963+ case 1925LLU: // try next case
2381523964 {
2381623965 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2381723966 exit(-1);
2381823967 }
23819- case 1910LLU: // completed switch
23968+ case 1924LLU: // completed switch
2382023969 {
23821- if(!stack[base + 36]/*mutable*/)
23970+ if(!stack[base + 38]/*mutable*/)
2382223971 {
23823- label = 1927LLU; // jump to alternative
23972+ label = 1941LLU; // jump to alternative
2382423973 break;
2382523974 }
2382623975
@@ -23827,274 +23976,274 @@
2382723976 // consequent
2382823977 fprintf(stderr, "%s", "in function ");
2382923978 // call reportid from ProcCall
23830- stack[base + 37LLU] = 1929LLU/*throw to this address*/;
23831- stack[base + 38LLU] = base;
23832- stack[base + 39LLU] = 1930LLU;
23979+ stack[base + 39LLU] = 1943LLU/*throw to this address*/;
23980+ stack[base + 40LLU] = base;
23981+ stack[base + 41LLU] = 1944LLU;
2383323982 // arguments for call to reportid
23834- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
23983+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2383523984 // set stack-base & callee-address
23836- base += 40LLU;
23985+ base += 42LLU;
2383723986 label = 18446744073709551586LLU; // reportid
2383823987 break;
2383923988 }
23840- case 1929LLU: // copy-back deleter (reportid to ProcCall)
23989+ case 1943LLU: // copy-back deleter (reportid to ProcCall)
2384123990 {
2384223991 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2384323992 // copy mutable arguments back from call to reportid
23844- label = 1836LLU; // continue to roll stack
23993+ label = 1850LLU; // continue to roll stack
2384523994 break;
2384623995 }
23847- case 1930LLU: // return from reportid to ProcCall
23996+ case 1944LLU: // return from reportid to ProcCall
2384823997 {
2384923998 // copy mutable arguments back from call to reportid
2385023999 fprintf(stderr, "%s", ", calling ");
2385124000 // call reportid from ProcCall
23852- stack[base + 37LLU] = 1931LLU/*throw to this address*/;
23853- stack[base + 38LLU] = base;
23854- stack[base + 39LLU] = 1932LLU;
24001+ stack[base + 39LLU] = 1945LLU/*throw to this address*/;
24002+ stack[base + 40LLU] = base;
24003+ stack[base + 41LLU] = 1946LLU;
2385524004 // arguments for call to reportid
23856- stack[base + 40LLU] = stack[base + 23]/*ceid*/;
24005+ stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2385724006 // set stack-base & callee-address
23858- base += 40LLU;
24007+ base += 42LLU;
2385924008 label = 18446744073709551586LLU; // reportid
2386024009 break;
2386124010 }
23862- case 1931LLU: // copy-back deleter (reportid to ProcCall)
24011+ case 1945LLU: // copy-back deleter (reportid to ProcCall)
2386324012 {
2386424013 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2386524014 // copy mutable arguments back from call to reportid
23866- label = 1836LLU; // continue to roll stack
24015+ label = 1850LLU; // continue to roll stack
2386724016 break;
2386824017 }
23869- case 1932LLU: // return from reportid to ProcCall
24018+ case 1946LLU: // return from reportid to ProcCall
2387024019 {
2387124020 // copy mutable arguments back from call to reportid
2387224021 fprintf(stderr, "%s", ": ");
2387324022 fprintf(stderr, "%s", "can't use constant argument ");
2387424023 // call printnr from ProcCall
23875- stack[base + 37LLU] = 1933LLU/*throw to this address*/;
23876- stack[base + 38LLU] = base;
23877- stack[base + 39LLU] = 1934LLU;
24024+ stack[base + 39LLU] = 1947LLU/*throw to this address*/;
24025+ stack[base + 40LLU] = base;
24026+ stack[base + 41LLU] = 1948LLU;
2387824027 // arguments for call to printnr
23879- stack[base + 40LLU] = stack[base + 15]/*content*/;
24028+ stack[base + 42LLU] = stack[base + 16]/*content*/;
2388024029 // set stack-base & callee-address
23881- base += 40LLU;
24030+ base += 42LLU;
2388224031 label = 18446744073709551590LLU; // printnr
2388324032 break;
2388424033 }
23885- case 1933LLU: // copy-back deleter (printnr to ProcCall)
24034+ case 1947LLU: // copy-back deleter (printnr to ProcCall)
2388624035 {
2388724036 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2388824037 // copy mutable arguments back from call to printnr
23889- label = 1836LLU; // continue to roll stack
24038+ label = 1850LLU; // continue to roll stack
2389024039 break;
2389124040 }
23892- case 1934LLU: // return from printnr to ProcCall
24041+ case 1948LLU: // return from printnr to ProcCall
2389324042 {
2389424043 // copy mutable arguments back from call to printnr
2389524044 printf("%s", " for mutable parameter ");
2389624045 // call reportti from ProcCall
23897- stack[base + 37LLU] = 1935LLU/*throw to this address*/;
23898- stack[base + 38LLU] = base;
23899- stack[base + 39LLU] = 1936LLU;
24046+ stack[base + 39LLU] = 1949LLU/*throw to this address*/;
24047+ stack[base + 40LLU] = base;
24048+ stack[base + 41LLU] = 1950LLU;
2390024049 // arguments for call to reportti
23901- stack[base + 40LLU] = stack[base + 35]/*typeid*/;
24050+ stack[base + 42LLU] = stack[base + 37]/*typeid*/;
2390224051 // set stack-base & callee-address
23903- base += 40LLU;
24052+ base += 42LLU;
2390424053 label = 360LLU; // reportti
2390524054 break;
2390624055 }
23907- case 1935LLU: // copy-back deleter (reportti to ProcCall)
24056+ case 1949LLU: // copy-back deleter (reportti to ProcCall)
2390824057 {
2390924058 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n");
2391024059 // copy mutable arguments back from call to reportti
23911- label = 1836LLU; // continue to roll stack
24060+ label = 1850LLU; // continue to roll stack
2391224061 break;
2391324062 }
23914- case 1936LLU: // return from reportti to ProcCall
24063+ case 1950LLU: // return from reportti to ProcCall
2391524064 {
2391624065 // copy mutable arguments back from call to reportti
2391724066 fprintf(stderr, "%s", "\n");
2391824067 exit(-1);
23919- label = 1928LLU; // consequent complete
24068+ label = 1942LLU; // consequent complete
2392024069 break;
2392124070 }
23922- case 1927LLU: // alternative
24071+ case 1941LLU: // alternative
2392324072 {
23924- label = 1928LLU; // alternative complete
24073+ label = 1942LLU; // alternative complete
2392524074 break;
2392624075 }
23927- case 1928LLU: // completed if-then-else
24076+ case 1942LLU: // completed if-then-else
2392824077 {
23929- ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 36];
23930- ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 35];
23931- label = 1908LLU; // case complete
24078+ ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
24079+ ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24080+ label = 1922LLU; // case complete
2393224081 break;
2393324082 }
23934- case 1909LLU: // try next case
24083+ case 1923LLU: // try next case
2393524084 {
2393624085 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2393724086 exit(-1);
2393824087 }
23939- case 1908LLU: // completed switch
24088+ case 1922LLU: // completed switch
2394024089 {
2394124090 printf("%s", "\n stack[base + ");
2394224091 // call printnr from ProcCall
23943- stack[base + 35LLU] = 1937LLU/*throw to this address*/;
23944- stack[base + 36LLU] = base;
23945- stack[base + 37LLU] = 1938LLU;
24092+ stack[base + 37LLU] = 1951LLU/*throw to this address*/;
24093+ stack[base + 38LLU] = base;
24094+ stack[base + 39LLU] = 1952LLU;
2394624095 // arguments for call to printnr
23947- stack[base + 38LLU] = stack[base + 28]/*sum*/;
24096+ stack[base + 40LLU] = stack[base + 30]/*sum*/;
2394824097 // set stack-base & callee-address
23949- base += 38LLU;
24098+ base += 40LLU;
2395024099 label = 18446744073709551590LLU; // printnr
2395124100 break;
2395224101 }
23953- case 1937LLU: // copy-back deleter (printnr to ProcCall)
24102+ case 1951LLU: // copy-back deleter (printnr to ProcCall)
2395424103 {
2395524104 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2395624105 // copy mutable arguments back from call to printnr
23957- label = 1836LLU; // continue to roll stack
24106+ label = 1850LLU; // continue to roll stack
2395824107 break;
2395924108 }
23960- case 1938LLU: // return from printnr to ProcCall
24109+ case 1952LLU: // return from printnr to ProcCall
2396124110 {
2396224111 // copy mutable arguments back from call to printnr
2396324112 printf("%s", "LLU] = ");
2396424113 // call printnr from ProcCall
23965- stack[base + 35LLU] = 1939LLU/*throw to this address*/;
23966- stack[base + 36LLU] = base;
23967- stack[base + 37LLU] = 1940LLU;
24114+ stack[base + 37LLU] = 1953LLU/*throw to this address*/;
24115+ stack[base + 38LLU] = base;
24116+ stack[base + 39LLU] = 1954LLU;
2396824117 // arguments for call to printnr
23969- stack[base + 38LLU] = stack[base + 15]/*content*/;
24118+ stack[base + 40LLU] = stack[base + 16]/*content*/;
2397024119 // set stack-base & callee-address
23971- base += 38LLU;
24120+ base += 40LLU;
2397224121 label = 18446744073709551590LLU; // printnr
2397324122 break;
2397424123 }
23975- case 1939LLU: // copy-back deleter (printnr to ProcCall)
24124+ case 1953LLU: // copy-back deleter (printnr to ProcCall)
2397624125 {
2397724126 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2397824127 // copy mutable arguments back from call to printnr
23979- label = 1836LLU; // continue to roll stack
24128+ label = 1850LLU; // continue to roll stack
2398024129 break;
2398124130 }
23982- case 1940LLU: // return from printnr to ProcCall
24131+ case 1954LLU: // return from printnr to ProcCall
2398324132 {
2398424133 // copy mutable arguments back from call to printnr
2398524134 printf("%s", "LLU;");
23986- label = 1907LLU; // consequent complete
24135+ label = 1921LLU; // consequent complete
2398724136 break;
2398824137 }
23989- case 1906LLU: // alternative
24138+ case 1920LLU: // alternative
2399024139 {
2399124140 // call equ from ProcCall
23992- stack[base + 35LLU] = 1941LLU/*throw to this address*/;
23993- stack[base + 36LLU] = base;
23994- stack[base + 37LLU] = 1942LLU;
24141+ stack[base + 37LLU] = 1955LLU/*throw to this address*/;
24142+ stack[base + 38LLU] = base;
24143+ stack[base + 39LLU] = 1956LLU;
2399524144 // arguments for call to equ
23996- stack[base + 39LLU] = stack[base + 14]/*variant*/;
23997- stack[base + 40LLU] = 4LLU;
24145+ stack[base + 41LLU] = stack[base + 15]/*variant*/;
24146+ stack[base + 42LLU] = 4LLU;
2399824147 // set stack-base & callee-address
23999- base += 38LLU;
24148+ base += 40LLU;
2400024149 label = 18446744073709551600LLU; // equ
2400124150 break;
2400224151 }
24003- case 1941LLU: // copy-back deleter (equ to ProcCall)
24152+ case 1955LLU: // copy-back deleter (equ to ProcCall)
2400424153 {
2400524154 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
2400624155 // copy mutable arguments back from call to equ
24007- label = 1836LLU; // continue to roll stack
24156+ label = 1850LLU; // continue to roll stack
2400824157 break;
2400924158 }
24010- case 1942LLU: // return from equ to ProcCall
24159+ case 1956LLU: // return from equ to ProcCall
2401124160 {
2401224161 // copy mutable arguments back from call to equ
2401324162 // copy back results provided by call to equ
24014- stack[base + 17] = stack[base + 38LLU];
24015- if(!stack[base + 17]/*isequal*/)
24163+ stack[base + 18] = stack[base + 40LLU];
24164+ if(!stack[base + 18]/*isequal*/)
2401624165 {
24017- label = 1943LLU; // jump to alternative
24166+ label = 1957LLU; // jump to alternative
2401824167 break;
2401924168 }
2402024169
2402124170 // consequent
24022- if(/*param*/0 != ((uint64_t *)(stack[base + 33]/*param*/))[0])
24171+ if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
2402324172 {
24024- label = 1946LLU; // jump to alternative
24173+ label = 1960LLU; // jump to alternative
2402524174 break;
2402624175 }
2402724176
24028- /*typeid*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*param*/))[1][0]/*typeid*/;
24029- /*mutable*/stack[base + 36] = ((uint64_t **)(stack[base + 33]/*param*/))[1][1]/*mutable*/;
24177+ /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/;
24178+ /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/;
2403024179
2403124180 // case
24032- if(/*typeid*/0 != ((uint64_t *)(stack[base + 35]/*typeid*/))[0])
24181+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
2403324182 {
24034- label = 1948LLU; // jump to alternative
24183+ label = 1962LLU; // jump to alternative
2403524184 break;
2403624185 }
2403724186
24038- /*expected*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][0]/*type*/;
24039- /*paramname*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][1]/*id*/;
24187+ /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/;
24188+ /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/;
2404024189
2404124190 // case
2404224191 // call getlettype from ProcCall
24043- stack[base + 40LLU] = 1949LLU/*throw to this address*/;
24044- stack[base + 41LLU] = base;
24045- stack[base + 42LLU] = 1950LLU;
24192+ stack[base + 42LLU] = 1963LLU/*throw to this address*/;
24193+ stack[base + 43LLU] = base;
24194+ stack[base + 44LLU] = 1964LLU;
2404624195 // arguments for call to getlettype
24047- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
24048- stack[base + 45LLU] = stack[base + 15]/*content*/;
24049- stack[base + 46LLU] = stack[base + 2]/*scopes*/;
24050- stack[base + 47LLU] = stack[base + 3]/*scope*/;
24196+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
24197+ stack[base + 47LLU] = stack[base + 16]/*content*/;
24198+ stack[base + 48LLU] = stack[base + 2]/*scopes*/;
24199+ stack[base + 49LLU] = stack[base + 3]/*scope*/;
2405124200 // set stack-base & callee-address
24052- base += 43LLU;
24201+ base += 45LLU;
2405324202 label = 618LLU; // getlettype
2405424203 break;
2405524204 }
24056- case 1949LLU: // copy-back deleter (getlettype to ProcCall)
24205+ case 1963LLU: // copy-back deleter (getlettype to ProcCall)
2405724206 {
2405824207 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (getlettype to ProcCall)\n");
2405924208 // copy mutable arguments back from call to getlettype
24060- label = 1836LLU; // continue to roll stack
24209+ label = 1850LLU; // continue to roll stack
2406124210 break;
2406224211 }
24063- case 1950LLU: // return from getlettype to ProcCall
24212+ case 1964LLU: // return from getlettype to ProcCall
2406424213 {
2406524214 // copy mutable arguments back from call to getlettype
2406624215 // copy back results provided by call to getlettype
24067- stack[base + 39] = stack[base + 43LLU];
24216+ stack[base + 41] = stack[base + 45LLU];
2406824217 // call findletmut from ProcCall
24069- stack[base + 41LLU] = 1951LLU/*throw to this address*/;
24070- stack[base + 42LLU] = base;
24071- stack[base + 43LLU] = 1952LLU;
24218+ stack[base + 43LLU] = 1965LLU/*throw to this address*/;
24219+ stack[base + 44LLU] = base;
24220+ stack[base + 45LLU] = 1966LLU;
2407224221 // arguments for call to findletmut
24073- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
24074- stack[base + 46LLU] = stack[base + 15]/*content*/;
24075- stack[base + 47LLU] = stack[base + 2]/*scopes*/;
24076- stack[base + 48LLU] = stack[base + 3]/*scope*/;
24222+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
24223+ stack[base + 48LLU] = stack[base + 16]/*content*/;
24224+ stack[base + 49LLU] = stack[base + 2]/*scopes*/;
24225+ stack[base + 50LLU] = stack[base + 3]/*scope*/;
2407724226 // set stack-base & callee-address
24078- base += 44LLU;
24227+ base += 46LLU;
2407924228 label = 636LLU; // findletmut
2408024229 break;
2408124230 }
24082- case 1951LLU: // copy-back deleter (findletmut to ProcCall)
24231+ case 1965LLU: // copy-back deleter (findletmut to ProcCall)
2408324232 {
2408424233 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (findletmut to ProcCall)\n");
2408524234 // copy mutable arguments back from call to findletmut
24086- label = 1836LLU; // continue to roll stack
24235+ label = 1850LLU; // continue to roll stack
2408724236 break;
2408824237 }
24089- case 1952LLU: // return from findletmut to ProcCall
24238+ case 1966LLU: // return from findletmut to ProcCall
2409024239 {
2409124240 // copy mutable arguments back from call to findletmut
2409224241 // copy back results provided by call to findletmut
24093- stack[base + 40] = stack[base + 44LLU];
24242+ stack[base + 42] = stack[base + 46LLU];
2409424243 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2409524244 if(!newstack)
2409624245 {
24097- label = 1836LLU; // throw: begin to unroll stack
24246+ label = 1850LLU; // throw: begin to unroll stack
2409824247 break;
2409924248 }
2410024249
@@ -24101,12 +24250,12 @@
2410124250 newstack[15LLU] = 9876543210LLU; // overflow-marker
2410224251 // call equtype from ProcCall
2410324252 newstack[0] = (uint64_t)stack; // backup stack location
24104- newstack[1] = 1953LLU;
24253+ newstack[1] = 1967LLU;
2410524254 newstack[2] = base;
24106- newstack[3] = 1954LLU;
24255+ newstack[3] = 1968LLU;
2410724256 // arguments for call to equtype
24108- newstack[5LLU] = stack[base + 39]/*type*/;
24109- newstack[6LLU] = stack[base + 37]/*expected*/;
24257+ newstack[5LLU] = stack[base + 41]/*type*/;
24258+ newstack[6LLU] = stack[base + 39]/*expected*/;
2411024259 stack = newstack;
2411124260 // set stack-base & callee-address
2411224261 base = 4/*deloffset*/;
@@ -24113,7 +24262,7 @@
2411324262 label = 335LLU; // equtype
2411424263 break;
2411524264 }
24116- case 1953LLU: // copy-back deleter (equtype to ProcCall)
24265+ case 1967LLU: // copy-back deleter (equtype to ProcCall)
2411724266 {
2411824267 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2411924268 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24125,15 +24274,15 @@
2412524274 }
2412624275 Free(15LLU + 1, sizeof(uint64_t), stack);
2412724276 stack = oldstack;
24128- label = 1836LLU; // continue to unroll stack
24277+ label = 1850LLU; // continue to unroll stack
2412924278 break;
2413024279 }
24131- case 1954LLU: // return from equtype to ProcCall
24280+ case 1968LLU: // return from equtype to ProcCall
2413224281 {
2413324282 uint64_t *oldstack = (uint64_t *)stack[0];
2413424283 // copy mutable arguments back from call to equtype
2413524284 // copy back results provided by call to equtype
24136- oldstack[base + 17] = stack[4LLU];
24285+ oldstack[base + 18] = stack[4LLU];
2413724286 if(stack[15LLU] != 9876543210LLU)
2413824287 {
2413924288 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -24141,82 +24290,82 @@
2414124290 }
2414224291 Free(15LLU + 1, sizeof(uint64_t), stack);
2414324292 stack = oldstack;
24144- if(!stack[base + 17]/*isequal*/)
24293+ if(!stack[base + 18]/*isequal*/)
2414524294 {
24146- label = 1955LLU; // jump to alternative
24295+ label = 1969LLU; // jump to alternative
2414724296 break;
2414824297 }
2414924298
2415024299 // consequent
24151- label = 1956LLU; // consequent complete
24300+ label = 1970LLU; // consequent complete
2415224301 break;
2415324302 }
24154- case 1955LLU: // alternative
24303+ case 1969LLU: // alternative
2415524304 {
2415624305 fprintf(stderr, "%s", "in function ");
2415724306 // call reportid from ProcCall
24158- stack[base + 41LLU] = 1957LLU/*throw to this address*/;
24159- stack[base + 42LLU] = base;
24160- stack[base + 43LLU] = 1958LLU;
24307+ stack[base + 43LLU] = 1971LLU/*throw to this address*/;
24308+ stack[base + 44LLU] = base;
24309+ stack[base + 45LLU] = 1972LLU;
2416124310 // arguments for call to reportid
24162- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
24311+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2416324312 // set stack-base & callee-address
24164- base += 44LLU;
24313+ base += 46LLU;
2416524314 label = 18446744073709551586LLU; // reportid
2416624315 break;
2416724316 }
24168- case 1957LLU: // copy-back deleter (reportid to ProcCall)
24317+ case 1971LLU: // copy-back deleter (reportid to ProcCall)
2416924318 {
2417024319 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2417124320 // copy mutable arguments back from call to reportid
24172- label = 1836LLU; // continue to roll stack
24321+ label = 1850LLU; // continue to roll stack
2417324322 break;
2417424323 }
24175- case 1958LLU: // return from reportid to ProcCall
24324+ case 1972LLU: // return from reportid to ProcCall
2417624325 {
2417724326 // copy mutable arguments back from call to reportid
2417824327 fprintf(stderr, "%s", " call to ");
2417924328 // call reportid from ProcCall
24180- stack[base + 41LLU] = 1959LLU/*throw to this address*/;
24181- stack[base + 42LLU] = base;
24182- stack[base + 43LLU] = 1960LLU;
24329+ stack[base + 43LLU] = 1973LLU/*throw to this address*/;
24330+ stack[base + 44LLU] = base;
24331+ stack[base + 45LLU] = 1974LLU;
2418324332 // arguments for call to reportid
24184- stack[base + 44LLU] = stack[base + 23]/*ceid*/;
24333+ stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2418524334 // set stack-base & callee-address
24186- base += 44LLU;
24335+ base += 46LLU;
2418724336 label = 18446744073709551586LLU; // reportid
2418824337 break;
2418924338 }
24190- case 1959LLU: // copy-back deleter (reportid to ProcCall)
24339+ case 1973LLU: // copy-back deleter (reportid to ProcCall)
2419124340 {
2419224341 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2419324342 // copy mutable arguments back from call to reportid
24194- label = 1836LLU; // continue to roll stack
24343+ label = 1850LLU; // continue to roll stack
2419524344 break;
2419624345 }
24197- case 1960LLU: // return from reportid to ProcCall
24346+ case 1974LLU: // return from reportid to ProcCall
2419824347 {
2419924348 // copy mutable arguments back from call to reportid
2420024349 fprintf(stderr, "%s", " at position ");
2420124350 // call reportnr from ProcCall
24202- stack[base + 41LLU] = 1961LLU/*throw to this address*/;
24203- stack[base + 42LLU] = base;
24204- stack[base + 43LLU] = 1962LLU;
24351+ stack[base + 43LLU] = 1975LLU/*throw to this address*/;
24352+ stack[base + 44LLU] = base;
24353+ stack[base + 45LLU] = 1976LLU;
2420524354 // arguments for call to reportnr
24206- stack[base + 44LLU] = stack[base + 30]/*index*/;
24355+ stack[base + 46LLU] = stack[base + 32]/*index*/;
2420724356 // set stack-base & callee-address
24208- base += 44LLU;
24357+ base += 46LLU;
2420924358 label = 18446744073709551589LLU; // reportnr
2421024359 break;
2421124360 }
24212- case 1961LLU: // copy-back deleter (reportnr to ProcCall)
24361+ case 1975LLU: // copy-back deleter (reportnr to ProcCall)
2421324362 {
2421424363 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2421524364 // copy mutable arguments back from call to reportnr
24216- label = 1836LLU; // continue to roll stack
24365+ label = 1850LLU; // continue to roll stack
2421724366 break;
2421824367 }
24219- case 1962LLU: // return from reportnr to ProcCall
24368+ case 1976LLU: // return from reportnr to ProcCall
2422024369 {
2422124370 // copy mutable arguments back from call to reportnr
2422224371 fprintf(stderr, "%s", " parameter type ");
@@ -24223,7 +24372,7 @@
2422324372 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2422424373 if(!newstack)
2422524374 {
24226- label = 1836LLU; // throw: begin to unroll stack
24375+ label = 1850LLU; // throw: begin to unroll stack
2422724376 break;
2422824377 }
2422924378
@@ -24230,11 +24379,11 @@
2423024379 newstack[10LLU] = 9876543210LLU; // overflow-marker
2423124380 // call reporttype from ProcCall
2423224381 newstack[0] = (uint64_t)stack; // backup stack location
24233- newstack[1] = 1963LLU;
24382+ newstack[1] = 1977LLU;
2423424383 newstack[2] = base;
24235- newstack[3] = 1964LLU;
24384+ newstack[3] = 1978LLU;
2423624385 // arguments for call to reporttype
24237- newstack[4LLU] = stack[base + 37]/*expected*/;
24386+ newstack[4LLU] = stack[base + 39]/*expected*/;
2423824387 stack = newstack;
2423924388 // set stack-base & callee-address
2424024389 base = 4/*deloffset*/;
@@ -24241,7 +24390,7 @@
2424124390 label = 313LLU; // reporttype
2424224391 break;
2424324392 }
24244- case 1963LLU: // copy-back deleter (reporttype to ProcCall)
24393+ case 1977LLU: // copy-back deleter (reporttype to ProcCall)
2424524394 {
2424624395 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2424724396 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24253,10 +24402,10 @@
2425324402 }
2425424403 Free(10LLU + 1, sizeof(uint64_t), stack);
2425524404 stack = oldstack;
24256- label = 1836LLU; // continue to unroll stack
24405+ label = 1850LLU; // continue to unroll stack
2425724406 break;
2425824407 }
24259- case 1964LLU: // return from reporttype to ProcCall
24408+ case 1978LLU: // return from reporttype to ProcCall
2426024409 {
2426124410 uint64_t *oldstack = (uint64_t *)stack[0];
2426224411 // copy mutable arguments back from call to reporttype
@@ -24271,7 +24420,7 @@
2427124420 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2427224421 if(!newstack)
2427324422 {
24274- label = 1836LLU; // throw: begin to unroll stack
24423+ label = 1850LLU; // throw: begin to unroll stack
2427524424 break;
2427624425 }
2427724426
@@ -24278,11 +24427,11 @@
2427824427 newstack[10LLU] = 9876543210LLU; // overflow-marker
2427924428 // call reporttype from ProcCall
2428024429 newstack[0] = (uint64_t)stack; // backup stack location
24281- newstack[1] = 1965LLU;
24430+ newstack[1] = 1979LLU;
2428224431 newstack[2] = base;
24283- newstack[3] = 1966LLU;
24432+ newstack[3] = 1980LLU;
2428424433 // arguments for call to reporttype
24285- newstack[4LLU] = stack[base + 39]/*type*/;
24434+ newstack[4LLU] = stack[base + 41]/*type*/;
2428624435 stack = newstack;
2428724436 // set stack-base & callee-address
2428824437 base = 4/*deloffset*/;
@@ -24289,7 +24438,7 @@
2428924438 label = 313LLU; // reporttype
2429024439 break;
2429124440 }
24292- case 1965LLU: // copy-back deleter (reporttype to ProcCall)
24441+ case 1979LLU: // copy-back deleter (reporttype to ProcCall)
2429324442 {
2429424443 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2429524444 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24301,10 +24450,10 @@
2430124450 }
2430224451 Free(10LLU + 1, sizeof(uint64_t), stack);
2430324452 stack = oldstack;
24304- label = 1836LLU; // continue to unroll stack
24453+ label = 1850LLU; // continue to unroll stack
2430524454 break;
2430624455 }
24307- case 1966LLU: // return from reporttype to ProcCall
24456+ case 1980LLU: // return from reporttype to ProcCall
2430824457 {
2430924458 uint64_t *oldstack = (uint64_t *)stack[0];
2431024459 // copy mutable arguments back from call to reporttype
@@ -24317,52 +24466,52 @@
2431724466 stack = oldstack;
2431824467 fprintf(stderr, "%s", "\n");
2431924468 exit(-1);
24320- label = 1956LLU; // alternative complete
24469+ label = 1970LLU; // alternative complete
2432124470 break;
2432224471 }
24323- case 1956LLU: // completed if-then-else
24472+ case 1970LLU: // completed if-then-else
2432424473 {
24325- if(!stack[base + 36]/*mutable*/)
24474+ if(!stack[base + 38]/*mutable*/)
2432624475 {
24327- label = 1967LLU; // jump to alternative
24476+ label = 1981LLU; // jump to alternative
2432824477 break;
2432924478 }
2433024479
2433124480 // consequent
24332- if(!stack[base + 40]/*mutarg*/)
24481+ if(!stack[base + 42]/*mutarg*/)
2433324482 {
24334- label = 1969LLU; // jump to alternative
24483+ label = 1983LLU; // jump to alternative
2433524484 break;
2433624485 }
2433724486
2433824487 // consequent
2433924488 // call lookidnr from ProcCall
24340- stack[base + 42LLU] = 1971LLU/*throw to this address*/;
24341- stack[base + 43LLU] = base;
24342- stack[base + 44LLU] = 1972LLU;
24489+ stack[base + 44LLU] = 1985LLU/*throw to this address*/;
24490+ stack[base + 45LLU] = base;
24491+ stack[base + 46LLU] = 1986LLU;
2434324492 // arguments for call to lookidnr
24344- stack[base + 46LLU] = stack[base + 18]/*copyback*/;
24345- stack[base + 47LLU] = stack[base + 15]/*content*/;
24493+ stack[base + 48LLU] = stack[base + 19]/*copyback*/;
24494+ stack[base + 49LLU] = stack[base + 16]/*content*/;
2434624495 // set stack-base & callee-address
24347- base += 45LLU;
24496+ base += 47LLU;
2434824497 label = 760LLU; // lookidnr
2434924498 break;
2435024499 }
24351- case 1971LLU: // copy-back deleter (lookidnr to ProcCall)
24500+ case 1985LLU: // copy-back deleter (lookidnr to ProcCall)
2435224501 {
2435324502 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n");
2435424503 // copy mutable arguments back from call to lookidnr
24355- label = 1836LLU; // continue to roll stack
24504+ label = 1850LLU; // continue to roll stack
2435624505 break;
2435724506 }
24358- case 1972LLU: // return from lookidnr to ProcCall
24507+ case 1986LLU: // return from lookidnr to ProcCall
2435924508 {
2436024509 // copy mutable arguments back from call to lookidnr
2436124510 // copy back results provided by call to lookidnr
24362- stack[base + 41] = stack[base + 45LLU];
24363- if(!stack[base + 41]/*found*/)
24511+ stack[base + 43] = stack[base + 47LLU];
24512+ if(!stack[base + 43]/*found*/)
2436424513 {
24365- label = 1973LLU; // jump to alternative
24514+ label = 1987LLU; // jump to alternative
2436624515 break;
2436724516 }
2436824517
@@ -24369,102 +24518,102 @@
2436924518 // consequent
2437024519 fprintf(stderr, "%s", "in function ");
2437124520 // call reportid from ProcCall
24372- stack[base + 42LLU] = 1975LLU/*throw to this address*/;
24373- stack[base + 43LLU] = base;
24374- stack[base + 44LLU] = 1976LLU;
24521+ stack[base + 44LLU] = 1989LLU/*throw to this address*/;
24522+ stack[base + 45LLU] = base;
24523+ stack[base + 46LLU] = 1990LLU;
2437524524 // arguments for call to reportid
24376- stack[base + 45LLU] = stack[base + 7]/*fnid*/;
24525+ stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2437724526 // set stack-base & callee-address
24378- base += 45LLU;
24527+ base += 47LLU;
2437924528 label = 18446744073709551586LLU; // reportid
2438024529 break;
2438124530 }
24382- case 1975LLU: // copy-back deleter (reportid to ProcCall)
24531+ case 1989LLU: // copy-back deleter (reportid to ProcCall)
2438324532 {
2438424533 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2438524534 // copy mutable arguments back from call to reportid
24386- label = 1836LLU; // continue to roll stack
24535+ label = 1850LLU; // continue to roll stack
2438724536 break;
2438824537 }
24389- case 1976LLU: // return from reportid to ProcCall
24538+ case 1990LLU: // return from reportid to ProcCall
2439024539 {
2439124540 // copy mutable arguments back from call to reportid
2439224541 fprintf(stderr, "%s", " call to ");
2439324542 // call reportid from ProcCall
24394- stack[base + 42LLU] = 1977LLU/*throw to this address*/;
24395- stack[base + 43LLU] = base;
24396- stack[base + 44LLU] = 1978LLU;
24543+ stack[base + 44LLU] = 1991LLU/*throw to this address*/;
24544+ stack[base + 45LLU] = base;
24545+ stack[base + 46LLU] = 1992LLU;
2439724546 // arguments for call to reportid
24398- stack[base + 45LLU] = stack[base + 23]/*ceid*/;
24547+ stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2439924548 // set stack-base & callee-address
24400- base += 45LLU;
24549+ base += 47LLU;
2440124550 label = 18446744073709551586LLU; // reportid
2440224551 break;
2440324552 }
24404- case 1977LLU: // copy-back deleter (reportid to ProcCall)
24553+ case 1991LLU: // copy-back deleter (reportid to ProcCall)
2440524554 {
2440624555 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2440724556 // copy mutable arguments back from call to reportid
24408- label = 1836LLU; // continue to roll stack
24557+ label = 1850LLU; // continue to roll stack
2440924558 break;
2441024559 }
24411- case 1978LLU: // return from reportid to ProcCall
24560+ case 1992LLU: // return from reportid to ProcCall
2441224561 {
2441324562 // copy mutable arguments back from call to reportid
2441424563 fprintf(stderr, "%s", " - duplicate mutable argument ");
2441524564 // call reportid from ProcCall
24416- stack[base + 42LLU] = 1979LLU/*throw to this address*/;
24417- stack[base + 43LLU] = base;
24418- stack[base + 44LLU] = 1980LLU;
24565+ stack[base + 44LLU] = 1993LLU/*throw to this address*/;
24566+ stack[base + 45LLU] = base;
24567+ stack[base + 46LLU] = 1994LLU;
2441924568 // arguments for call to reportid
24420- stack[base + 45LLU] = stack[base + 15]/*content*/;
24569+ stack[base + 47LLU] = stack[base + 16]/*content*/;
2442124570 // set stack-base & callee-address
24422- base += 45LLU;
24571+ base += 47LLU;
2442324572 label = 18446744073709551586LLU; // reportid
2442424573 break;
2442524574 }
24426- case 1979LLU: // copy-back deleter (reportid to ProcCall)
24575+ case 1993LLU: // copy-back deleter (reportid to ProcCall)
2442724576 {
2442824577 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2442924578 // copy mutable arguments back from call to reportid
24430- label = 1836LLU; // continue to roll stack
24579+ label = 1850LLU; // continue to roll stack
2443124580 break;
2443224581 }
24433- case 1980LLU: // return from reportid to ProcCall
24582+ case 1994LLU: // return from reportid to ProcCall
2443424583 {
2443524584 // copy mutable arguments back from call to reportid
2443624585 fprintf(stderr, "%s", "\n");
2443724586 exit(-1);
24438- label = 1974LLU; // consequent complete
24587+ label = 1988LLU; // consequent complete
2443924588 break;
2444024589 }
24441- case 1973LLU: // alternative
24590+ case 1987LLU: // alternative
2444224591 {
24443- label = 1974LLU; // alternative complete
24592+ label = 1988LLU; // alternative complete
2444424593 break;
2444524594 }
24446- case 1974LLU: // completed if-then-else
24595+ case 1988LLU: // completed if-then-else
2444724596 {
24448- label = 1982LLU; // skip deleter
24597+ label = 1996LLU; // skip deleter
2444924598 break;
2445024599 }
24451- case 1981LLU: // deleter
24600+ case 1995LLU: // deleter
2445224601 {
2445324602 // throw from ProcCall
24454- if(!stack[base + 41])
24603+ if(!stack[base + 43])
2445524604 {
2445624605 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
24457- label = 1836LLU; // skip, variable already deleted/unscoped
24606+ label = 1850LLU; // skip, variable already deleted/unscoped
2445824607 break;
2445924608 }
2446024609 fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");
2446124610
24462- uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
24611+ uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4);
2446324612 // call ~idnr from ProcCall
2446424613 newstack[0] = (uint64_t)stack; // backup stack location
2446524614 newstack[1] = 1234567890;
2446624615 newstack[2] = base;
24467- newstack[3] = 1983LLU;
24616+ newstack[3] = 1997LLU;
2446824617 stack = newstack;
2446924618 // set stack-base & callee-address
2447024619 base = 4/*deloffset*/;
@@ -24471,28 +24620,28 @@
2447124620 label = 758LLU; // ~idnr
2447224621 break;
2447324622 }
24474- case 1983LLU: // return from ~idnr to ProcCall
24623+ case 1997LLU: // return from ~idnr to ProcCall
2447524624 {
2447624625 stack = (uint64_t *)stack[0];
2447724626 // releasing toplevel container
24478- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4));
24627+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2447924628
24480- label = 1836LLU; // continue unrolling stack, delete next variable
24629+ label = 1850LLU; // continue unrolling stack, delete next variable
2448124630 break;
2448224631 }
24483- case 1982LLU: // skipped deleter
24632+ case 1996LLU: // skipped deleter
2448424633 {
2448524634 // construct idnr.idnr
24486- if(!(stack[base + 41] = construct(2)))
24635+ if(!(stack[base + 43] = construct(2)))
2448724636 {
24488- label = 1836LLU; // throw: begin to unroll stack
24637+ label = 1850LLU; // throw: begin to unroll stack
2448924638 break;
2449024639 }
2449124640
2449224641 // consequent
24493- ((uint64_t *)stack[base + 41])[0] = 0;
24494- (((uint64_t **)(stack[base + 41]))[1][0]) = stack[base + 15]/*content*/;
24495- (((uint64_t **)(stack[base + 41]))[1][1]) = stack[base + 28]/*sum*/;
24642+ ((uint64_t *)stack[base + 43])[0] = 0;
24643+ (((uint64_t **)(stack[base + 43]))[1][0]) = stack[base + 16]/*content*/;
24644+ (((uint64_t **)(stack[base + 43]))[1][1]) = stack[base + 30]/*sum*/;
2449624645 {
2449724646 struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
2449824647 if(!list)
@@ -24500,57 +24649,57 @@
2450024649 fprintf(stderr, "in function ProcCall push to [idnr]: OUT OF MEMORY!");
2450124650 exit(-1);
2450224651 }
24503- list->next = (struct listnode *)stack[base + 18]/*copyback*/;
24504- stack[base + 18]/*copyback*/ = (uint64_t)list;
24505- MOVE(&list->data, &stack[base + 41]/*idnr*/);
24652+ list->next = (struct listnode *)stack[base + 19]/*copyback*/;
24653+ stack[base + 19]/*copyback*/ = (uint64_t)list;
24654+ MOVE(&list->data, &stack[base + 43]/*idnr*/);
2450624655 }
24507- label = 1970LLU; // consequent complete
24656+ label = 1984LLU; // consequent complete
2450824657 break;
2450924658 }
24510- case 1969LLU: // alternative
24659+ case 1983LLU: // alternative
2451124660 {
2451224661 fprintf(stderr, "%s", "in function ");
2451324662 // call reportid from ProcCall
24514- stack[base + 41LLU] = 1984LLU/*throw to this address*/;
24515- stack[base + 42LLU] = base;
24516- stack[base + 43LLU] = 1985LLU;
24663+ stack[base + 43LLU] = 1998LLU/*throw to this address*/;
24664+ stack[base + 44LLU] = base;
24665+ stack[base + 45LLU] = 1999LLU;
2451724666 // arguments for call to reportid
24518- stack[base + 44LLU] = stack[base + 7]/*fnid*/;
24667+ stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2451924668 // set stack-base & callee-address
24520- base += 44LLU;
24669+ base += 46LLU;
2452124670 label = 18446744073709551586LLU; // reportid
2452224671 break;
2452324672 }
24524- case 1984LLU: // copy-back deleter (reportid to ProcCall)
24673+ case 1998LLU: // copy-back deleter (reportid to ProcCall)
2452524674 {
2452624675 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2452724676 // copy mutable arguments back from call to reportid
24528- label = 1836LLU; // continue to roll stack
24677+ label = 1850LLU; // continue to roll stack
2452924678 break;
2453024679 }
24531- case 1985LLU: // return from reportid to ProcCall
24680+ case 1999LLU: // return from reportid to ProcCall
2453224681 {
2453324682 // copy mutable arguments back from call to reportid
2453424683 fprintf(stderr, "%s", ", call to ");
2453524684 // call reportid from ProcCall
24536- stack[base + 41LLU] = 1986LLU/*throw to this address*/;
24537- stack[base + 42LLU] = base;
24538- stack[base + 43LLU] = 1987LLU;
24685+ stack[base + 43LLU] = 2000LLU/*throw to this address*/;
24686+ stack[base + 44LLU] = base;
24687+ stack[base + 45LLU] = 2001LLU;
2453924688 // arguments for call to reportid
24540- stack[base + 44LLU] = stack[base + 23]/*ceid*/;
24689+ stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2454124690 // set stack-base & callee-address
24542- base += 44LLU;
24691+ base += 46LLU;
2454324692 label = 18446744073709551586LLU; // reportid
2454424693 break;
2454524694 }
24546- case 1986LLU: // copy-back deleter (reportid to ProcCall)
24695+ case 2000LLU: // copy-back deleter (reportid to ProcCall)
2454724696 {
2454824697 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2454924698 // copy mutable arguments back from call to reportid
24550- label = 1836LLU; // continue to roll stack
24699+ label = 1850LLU; // continue to roll stack
2455124700 break;
2455224701 }
24553- case 1987LLU: // return from reportid to ProcCall
24702+ case 2001LLU: // return from reportid to ProcCall
2455424703 {
2455524704 // copy mutable arguments back from call to reportid
2455624705 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -24557,7 +24706,7 @@
2455724706 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2455824707 if(!newstack)
2455924708 {
24560- label = 1836LLU; // throw: begin to unroll stack
24709+ label = 1850LLU; // throw: begin to unroll stack
2456124710 break;
2456224711 }
2456324712
@@ -24564,11 +24713,11 @@
2456424713 newstack[10LLU] = 9876543210LLU; // overflow-marker
2456524714 // call reporttype from ProcCall
2456624715 newstack[0] = (uint64_t)stack; // backup stack location
24567- newstack[1] = 1988LLU;
24716+ newstack[1] = 2002LLU;
2456824717 newstack[2] = base;
24569- newstack[3] = 1989LLU;
24718+ newstack[3] = 2003LLU;
2457024719 // arguments for call to reporttype
24571- newstack[4LLU] = stack[base + 39]/*type*/;
24720+ newstack[4LLU] = stack[base + 41]/*type*/;
2457224721 stack = newstack;
2457324722 // set stack-base & callee-address
2457424723 base = 4/*deloffset*/;
@@ -24575,7 +24724,7 @@
2457524724 label = 313LLU; // reporttype
2457624725 break;
2457724726 }
24578- case 1988LLU: // copy-back deleter (reporttype to ProcCall)
24727+ case 2002LLU: // copy-back deleter (reporttype to ProcCall)
2457924728 {
2458024729 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2458124730 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24587,10 +24736,10 @@
2458724736 }
2458824737 Free(10LLU + 1, sizeof(uint64_t), stack);
2458924738 stack = oldstack;
24590- label = 1836LLU; // continue to unroll stack
24739+ label = 1850LLU; // continue to unroll stack
2459124740 break;
2459224741 }
24593- case 1989LLU: // return from reporttype to ProcCall
24742+ case 2003LLU: // return from reporttype to ProcCall
2459424743 {
2459524744 uint64_t *oldstack = (uint64_t *)stack[0];
2459624745 // copy mutable arguments back from call to reporttype
@@ -24603,24 +24752,24 @@
2460324752 stack = oldstack;
2460424753 fprintf(stderr, "%s", " ");
2460524754 // call reportid from ProcCall
24606- stack[base + 41LLU] = 1990LLU/*throw to this address*/;
24607- stack[base + 42LLU] = base;
24608- stack[base + 43LLU] = 1991LLU;
24755+ stack[base + 43LLU] = 2004LLU/*throw to this address*/;
24756+ stack[base + 44LLU] = base;
24757+ stack[base + 45LLU] = 2005LLU;
2460924758 // arguments for call to reportid
24610- stack[base + 44LLU] = stack[base + 15]/*content*/;
24759+ stack[base + 46LLU] = stack[base + 16]/*content*/;
2461124760 // set stack-base & callee-address
24612- base += 44LLU;
24761+ base += 46LLU;
2461324762 label = 18446744073709551586LLU; // reportid
2461424763 break;
2461524764 }
24616- case 1990LLU: // copy-back deleter (reportid to ProcCall)
24765+ case 2004LLU: // copy-back deleter (reportid to ProcCall)
2461724766 {
2461824767 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2461924768 // copy mutable arguments back from call to reportid
24620- label = 1836LLU; // continue to roll stack
24769+ label = 1850LLU; // continue to roll stack
2462124770 break;
2462224771 }
24623- case 1991LLU: // return from reportid to ProcCall
24772+ case 2005LLU: // return from reportid to ProcCall
2462424773 {
2462524774 // copy mutable arguments back from call to reportid
2462624775 fprintf(stderr, "%s", " into mutable parameter ");
@@ -24627,7 +24776,7 @@
2462724776 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2462824777 if(!newstack)
2462924778 {
24630- label = 1836LLU; // throw: begin to unroll stack
24779+ label = 1850LLU; // throw: begin to unroll stack
2463124780 break;
2463224781 }
2463324782
@@ -24634,11 +24783,11 @@
2463424783 newstack[10LLU] = 9876543210LLU; // overflow-marker
2463524784 // call reporttype from ProcCall
2463624785 newstack[0] = (uint64_t)stack; // backup stack location
24637- newstack[1] = 1992LLU;
24786+ newstack[1] = 2006LLU;
2463824787 newstack[2] = base;
24639- newstack[3] = 1993LLU;
24788+ newstack[3] = 2007LLU;
2464024789 // arguments for call to reporttype
24641- newstack[4LLU] = stack[base + 37]/*expected*/;
24790+ newstack[4LLU] = stack[base + 39]/*expected*/;
2464224791 stack = newstack;
2464324792 // set stack-base & callee-address
2464424793 base = 4/*deloffset*/;
@@ -24645,7 +24794,7 @@
2464524794 label = 313LLU; // reporttype
2464624795 break;
2464724796 }
24648- case 1992LLU: // copy-back deleter (reporttype to ProcCall)
24797+ case 2006LLU: // copy-back deleter (reporttype to ProcCall)
2464924798 {
2465024799 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2465124800 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24657,10 +24806,10 @@
2465724806 }
2465824807 Free(10LLU + 1, sizeof(uint64_t), stack);
2465924808 stack = oldstack;
24660- label = 1836LLU; // continue to unroll stack
24809+ label = 1850LLU; // continue to unroll stack
2466124810 break;
2466224811 }
24663- case 1993LLU: // return from reporttype to ProcCall
24812+ case 2007LLU: // return from reporttype to ProcCall
2466424813 {
2466524814 uint64_t *oldstack = (uint64_t *)stack[0];
2466624815 // copy mutable arguments back from call to reporttype
@@ -24672,50 +24821,50 @@
2467224821 Free(10LLU + 1, sizeof(uint64_t), stack);
2467324822 stack = oldstack;
2467424823 // call reportid from ProcCall
24675- stack[base + 41LLU] = 1994LLU/*throw to this address*/;
24676- stack[base + 42LLU] = base;
24677- stack[base + 43LLU] = 1995LLU;
24824+ stack[base + 43LLU] = 2008LLU/*throw to this address*/;
24825+ stack[base + 44LLU] = base;
24826+ stack[base + 45LLU] = 2009LLU;
2467824827 // arguments for call to reportid
24679- stack[base + 44LLU] = stack[base + 38]/*paramname*/;
24828+ stack[base + 46LLU] = stack[base + 40]/*paramname*/;
2468024829 // set stack-base & callee-address
24681- base += 44LLU;
24830+ base += 46LLU;
2468224831 label = 18446744073709551586LLU; // reportid
2468324832 break;
2468424833 }
24685- case 1994LLU: // copy-back deleter (reportid to ProcCall)
24834+ case 2008LLU: // copy-back deleter (reportid to ProcCall)
2468624835 {
2468724836 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2468824837 // copy mutable arguments back from call to reportid
24689- label = 1836LLU; // continue to roll stack
24838+ label = 1850LLU; // continue to roll stack
2469024839 break;
2469124840 }
24692- case 1995LLU: // return from reportid to ProcCall
24841+ case 2009LLU: // return from reportid to ProcCall
2469324842 {
2469424843 // copy mutable arguments back from call to reportid
2469524844 fprintf(stderr, "%s", "\n");
2469624845 exit(-1);
24697- label = 1970LLU; // alternative complete
24846+ label = 1984LLU; // alternative complete
2469824847 break;
2469924848 }
24700- case 1970LLU: // completed if-then-else
24849+ case 1984LLU: // completed if-then-else
2470124850 {
24702- label = 1968LLU; // consequent complete
24851+ label = 1982LLU; // consequent complete
2470324852 break;
2470424853 }
24705- case 1967LLU: // alternative
24854+ case 1981LLU: // alternative
2470624855 {
24707- label = 1968LLU; // alternative complete
24856+ label = 1982LLU; // alternative complete
2470824857 break;
2470924858 }
24710- case 1968LLU: // completed if-then-else
24859+ case 1982LLU: // completed if-then-else
2471124860 {
2471224861
24713- uint64_t *newstack = (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4);
24862+ uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
2471424863 // call ~type from ProcCall
2471524864 newstack[0] = (uint64_t)stack; // backup stack location
2471624865 newstack[1] = 1234567890;
2471724866 newstack[2] = base;
24718- newstack[3] = 1996LLU;
24867+ newstack[3] = 2010LLU;
2471924868 stack = newstack;
2472024869 // set stack-base & callee-address
2472124870 base = 4/*deloffset*/;
@@ -24722,293 +24871,293 @@
2472224871 label = 295LLU; // ~type
2472324872 break;
2472424873 }
24725- case 1996LLU: // return from ~type to ProcCall
24874+ case 2010LLU: // return from ~type to ProcCall
2472624875 {
2472724876 stack = (uint64_t *)stack[0];
2472824877 // releasing toplevel container
24729- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4));
24878+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4));
2473024879
24731- ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
24732- ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24733- label = 1947LLU; // case complete
24880+ ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
24881+ ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
24882+ label = 1961LLU; // case complete
2473424883 break;
2473524884 }
24736- case 1948LLU: // try next case
24885+ case 1962LLU: // try next case
2473724886 {
2473824887 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2473924888 exit(-1);
2474024889 }
24741- case 1947LLU: // completed switch
24890+ case 1961LLU: // completed switch
2474224891 {
2474324892 printf("%s", "\n stack[base + ");
2474424893 // call printnr from ProcCall
24745- stack[base + 37LLU] = 1997LLU/*throw to this address*/;
24746- stack[base + 38LLU] = base;
24747- stack[base + 39LLU] = 1998LLU;
24894+ stack[base + 39LLU] = 2011LLU/*throw to this address*/;
24895+ stack[base + 40LLU] = base;
24896+ stack[base + 41LLU] = 2012LLU;
2474824897 // arguments for call to printnr
24749- stack[base + 40LLU] = stack[base + 28]/*sum*/;
24898+ stack[base + 42LLU] = stack[base + 30]/*sum*/;
2475024899 // set stack-base & callee-address
24751- base += 40LLU;
24900+ base += 42LLU;
2475224901 label = 18446744073709551590LLU; // printnr
2475324902 break;
2475424903 }
24755- case 1997LLU: // copy-back deleter (printnr to ProcCall)
24904+ case 2011LLU: // copy-back deleter (printnr to ProcCall)
2475624905 {
2475724906 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2475824907 // copy mutable arguments back from call to printnr
24759- label = 1836LLU; // continue to roll stack
24908+ label = 1850LLU; // continue to roll stack
2476024909 break;
2476124910 }
24762- case 1998LLU: // return from printnr to ProcCall
24911+ case 2012LLU: // return from printnr to ProcCall
2476324912 {
2476424913 // copy mutable arguments back from call to printnr
2476524914 printf("%s", "LLU] = ");
2476624915 // call emitvar from ProcCall
24767- stack[base + 37LLU] = 1999LLU/*throw to this address*/;
24768- stack[base + 38LLU] = base;
24769- stack[base + 39LLU] = 2000LLU;
24916+ stack[base + 39LLU] = 2013LLU/*throw to this address*/;
24917+ stack[base + 40LLU] = base;
24918+ stack[base + 41LLU] = 2014LLU;
2477024919 // arguments for call to emitvar
24771- stack[base + 40LLU] = stack[base + 7]/*fnid*/;
24772- stack[base + 41LLU] = stack[base + 15]/*content*/;
24773- stack[base + 42LLU] = stack[base + 2]/*scopes*/;
24774- stack[base + 43LLU] = stack[base + 3]/*scope*/;
24920+ stack[base + 42LLU] = stack[base + 8]/*fnid*/;
24921+ stack[base + 43LLU] = stack[base + 16]/*content*/;
24922+ stack[base + 44LLU] = stack[base + 2]/*scopes*/;
24923+ stack[base + 45LLU] = stack[base + 3]/*scope*/;
2477524924 // set stack-base & callee-address
24776- base += 40LLU;
24925+ base += 42LLU;
2477724926 label = 659LLU; // emitvar
2477824927 break;
2477924928 }
24780- case 1999LLU: // copy-back deleter (emitvar to ProcCall)
24929+ case 2013LLU: // copy-back deleter (emitvar to ProcCall)
2478124930 {
2478224931 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2478324932 // copy mutable arguments back from call to emitvar
24784- label = 1836LLU; // continue to roll stack
24933+ label = 1850LLU; // continue to roll stack
2478524934 break;
2478624935 }
24787- case 2000LLU: // return from emitvar to ProcCall
24936+ case 2014LLU: // return from emitvar to ProcCall
2478824937 {
2478924938 // copy mutable arguments back from call to emitvar
2479024939 printf("%s", ";");
24791- ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 36];
24792- ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 35];
24793- label = 1945LLU; // case complete
24940+ ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
24941+ ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24942+ label = 1959LLU; // case complete
2479424943 break;
2479524944 }
24796- case 1946LLU: // try next case
24945+ case 1960LLU: // try next case
2479724946 {
2479824947 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2479924948 exit(-1);
2480024949 }
24801- case 1945LLU: // completed switch
24950+ case 1959LLU: // completed switch
2480224951 {
24803- label = 1944LLU; // consequent complete
24952+ label = 1958LLU; // consequent complete
2480424953 break;
2480524954 }
24806- case 1943LLU: // alternative
24955+ case 1957LLU: // alternative
2480724956 {
2480824957 fprintf(stderr, "%s", "expected identifier or constant argument but found ");
2480924958 // call printtoken from ProcCall
24810- stack[base + 35LLU] = 2001LLU/*throw to this address*/;
24811- stack[base + 36LLU] = base;
24812- stack[base + 37LLU] = 2002LLU;
24959+ stack[base + 37LLU] = 2015LLU/*throw to this address*/;
24960+ stack[base + 38LLU] = base;
24961+ stack[base + 39LLU] = 2016LLU;
2481324962 // arguments for call to printtoken
24814- stack[base + 38LLU] = stack[base + 14]/*variant*/;
24815- stack[base + 39LLU] = stack[base + 15]/*content*/;
24963+ stack[base + 40LLU] = stack[base + 15]/*variant*/;
24964+ stack[base + 41LLU] = stack[base + 16]/*content*/;
2481624965 // set stack-base & callee-address
24817- base += 38LLU;
24966+ base += 40LLU;
2481824967 label = 18446744073709551583LLU; // printtoken
2481924968 break;
2482024969 }
24821- case 2001LLU: // copy-back deleter (printtoken to ProcCall)
24970+ case 2015LLU: // copy-back deleter (printtoken to ProcCall)
2482224971 {
2482324972 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n");
2482424973 // copy mutable arguments back from call to printtoken
24825- label = 1836LLU; // continue to roll stack
24974+ label = 1850LLU; // continue to roll stack
2482624975 break;
2482724976 }
24828- case 2002LLU: // return from printtoken to ProcCall
24977+ case 2016LLU: // return from printtoken to ProcCall
2482924978 {
2483024979 // copy mutable arguments back from call to printtoken
2483124980 fprintf(stderr, "%s", "\n");
2483224981 exit(-1);
24833- label = 1944LLU; // alternative complete
24982+ label = 1958LLU; // alternative complete
2483424983 break;
2483524984 }
24836- case 1944LLU: // completed if-then-else
24985+ case 1958LLU: // completed if-then-else
2483724986 {
24838- label = 1907LLU; // alternative complete
24987+ label = 1921LLU; // alternative complete
2483924988 break;
2484024989 }
24841- case 1907LLU: // completed if-then-else
24990+ case 1921LLU: // completed if-then-else
2484224991 {
24843- ((struct listnode *)(stack[base + 34]/*previous*/))->data = stack[base + 33];
24844- label = 1880LLU; // repeat
24992+ ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
24993+ label = 1894LLU; // repeat
2484524994 break;
2484624995 }
24847- case 1881LLU: // loop finished
24996+ case 1895LLU: // loop finished
2484824997 {
2484924998 printf("%s", "\n // set stack-base & callee-address");
24850- stack[base + 28]/*sum*/ = 0;
24999+ stack[base + 30]/*sum*/ = 0;
2485125000 // call add from ProcCall
24852- stack[base + 32LLU] = 2003LLU/*throw to this address*/;
24853- stack[base + 33LLU] = base;
24854- stack[base + 34LLU] = 2004LLU;
25001+ stack[base + 34LLU] = 2017LLU/*throw to this address*/;
25002+ stack[base + 35LLU] = base;
25003+ stack[base + 36LLU] = 2018LLU;
2485525004 // arguments for call to add
24856- stack[base + 36LLU] = stack[base + 4]/*offset*/;
24857- stack[base + 37LLU] = stack[base + 28]/*sum*/;
25005+ stack[base + 38LLU] = stack[base + 4]/*offset*/;
25006+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2485825007 // set stack-base & callee-address
24859- base += 35LLU;
25008+ base += 37LLU;
2486025009 label = 18446744073709551605LLU; // add
2486125010 break;
2486225011 }
24863- case 2003LLU: // copy-back deleter (add to ProcCall)
25012+ case 2017LLU: // copy-back deleter (add to ProcCall)
2486425013 {
2486525014 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2486625015 // copy mutable arguments back from call to add
24867- label = 1836LLU; // continue to roll stack
25016+ label = 1850LLU; // continue to roll stack
2486825017 break;
2486925018 }
24870- case 2004LLU: // return from add to ProcCall
25019+ case 2018LLU: // return from add to ProcCall
2487125020 {
2487225021 // copy mutable arguments back from call to add
2487325022 // copy back results provided by call to add
24874- stack[base + 28] = stack[base + 35LLU];
25023+ stack[base + 30] = stack[base + 37LLU];
2487525024 // call add from ProcCall
24876- stack[base + 32LLU] = 2005LLU/*throw to this address*/;
24877- stack[base + 33LLU] = base;
24878- stack[base + 34LLU] = 2006LLU;
25025+ stack[base + 34LLU] = 2019LLU/*throw to this address*/;
25026+ stack[base + 35LLU] = base;
25027+ stack[base + 36LLU] = 2020LLU;
2487925028 // arguments for call to add
24880- stack[base + 36LLU] = 3LLU;
24881- stack[base + 37LLU] = stack[base + 28]/*sum*/;
25029+ stack[base + 38LLU] = 3LLU;
25030+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2488225031 // set stack-base & callee-address
24883- base += 35LLU;
25032+ base += 37LLU;
2488425033 label = 18446744073709551605LLU; // add
2488525034 break;
2488625035 }
24887- case 2005LLU: // copy-back deleter (add to ProcCall)
25036+ case 2019LLU: // copy-back deleter (add to ProcCall)
2488825037 {
2488925038 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2489025039 // copy mutable arguments back from call to add
24891- label = 1836LLU; // continue to roll stack
25040+ label = 1850LLU; // continue to roll stack
2489225041 break;
2489325042 }
24894- case 2006LLU: // return from add to ProcCall
25043+ case 2020LLU: // return from add to ProcCall
2489525044 {
2489625045 // copy mutable arguments back from call to add
2489725046 // copy back results provided by call to add
24898- stack[base + 28] = stack[base + 35LLU];
25047+ stack[base + 30] = stack[base + 37LLU];
2489925048 // call add from ProcCall
24900- stack[base + 32LLU] = 2007LLU/*throw to this address*/;
24901- stack[base + 33LLU] = base;
24902- stack[base + 34LLU] = 2008LLU;
25049+ stack[base + 34LLU] = 2021LLU/*throw to this address*/;
25050+ stack[base + 35LLU] = base;
25051+ stack[base + 36LLU] = 2022LLU;
2490325052 // arguments for call to add
24904- stack[base + 36LLU] = stack[base + 9]/*fnrescount*/;
24905- stack[base + 37LLU] = stack[base + 28]/*sum*/;
25053+ stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
25054+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2490625055 // set stack-base & callee-address
24907- base += 35LLU;
25056+ base += 37LLU;
2490825057 label = 18446744073709551605LLU; // add
2490925058 break;
2491025059 }
24911- case 2007LLU: // copy-back deleter (add to ProcCall)
25060+ case 2021LLU: // copy-back deleter (add to ProcCall)
2491225061 {
2491325062 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2491425063 // copy mutable arguments back from call to add
24915- label = 1836LLU; // continue to roll stack
25064+ label = 1850LLU; // continue to roll stack
2491625065 break;
2491725066 }
24918- case 2008LLU: // return from add to ProcCall
25067+ case 2022LLU: // return from add to ProcCall
2491925068 {
2492025069 // copy mutable arguments back from call to add
2492125070 // copy back results provided by call to add
24922- stack[base + 28] = stack[base + 35LLU];
25071+ stack[base + 30] = stack[base + 37LLU];
2492325072 // call add from ProcCall
24924- stack[base + 32LLU] = 2009LLU/*throw to this address*/;
24925- stack[base + 33LLU] = base;
24926- stack[base + 34LLU] = 2010LLU;
25073+ stack[base + 34LLU] = 2023LLU/*throw to this address*/;
25074+ stack[base + 35LLU] = base;
25075+ stack[base + 36LLU] = 2024LLU;
2492725076 // arguments for call to add
24928- stack[base + 36LLU] = stack[base + 10]/*fnargcount*/;
24929- stack[base + 37LLU] = stack[base + 28]/*sum*/;
25077+ stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
25078+ stack[base + 39LLU] = stack[base + 30]/*sum*/;
2493025079 // set stack-base & callee-address
24931- base += 35LLU;
25080+ base += 37LLU;
2493225081 label = 18446744073709551605LLU; // add
2493325082 break;
2493425083 }
24935- case 2009LLU: // copy-back deleter (add to ProcCall)
25084+ case 2023LLU: // copy-back deleter (add to ProcCall)
2493625085 {
2493725086 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2493825087 // copy mutable arguments back from call to add
24939- label = 1836LLU; // continue to roll stack
25088+ label = 1850LLU; // continue to roll stack
2494025089 break;
2494125090 }
24942- case 2010LLU: // return from add to ProcCall
25091+ case 2024LLU: // return from add to ProcCall
2494325092 {
2494425093 // copy mutable arguments back from call to add
2494525094 // copy back results provided by call to add
24946- stack[base + 28] = stack[base + 35LLU];
25095+ stack[base + 30] = stack[base + 37LLU];
2494725096 printf("%s", "\n base += ");
2494825097 // call printnr from ProcCall
24949- stack[base + 32LLU] = 2011LLU/*throw to this address*/;
24950- stack[base + 33LLU] = base;
24951- stack[base + 34LLU] = 2012LLU;
25098+ stack[base + 34LLU] = 2025LLU/*throw to this address*/;
25099+ stack[base + 35LLU] = base;
25100+ stack[base + 36LLU] = 2026LLU;
2495225101 // arguments for call to printnr
24953- stack[base + 35LLU] = stack[base + 28]/*sum*/;
25102+ stack[base + 37LLU] = stack[base + 30]/*sum*/;
2495425103 // set stack-base & callee-address
24955- base += 35LLU;
25104+ base += 37LLU;
2495625105 label = 18446744073709551590LLU; // printnr
2495725106 break;
2495825107 }
24959- case 2011LLU: // copy-back deleter (printnr to ProcCall)
25108+ case 2025LLU: // copy-back deleter (printnr to ProcCall)
2496025109 {
2496125110 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2496225111 // copy mutable arguments back from call to printnr
24963- label = 1836LLU; // continue to roll stack
25112+ label = 1850LLU; // continue to roll stack
2496425113 break;
2496525114 }
24966- case 2012LLU: // return from printnr to ProcCall
25115+ case 2026LLU: // return from printnr to ProcCall
2496725116 {
2496825117 // copy mutable arguments back from call to printnr
2496925118 printf("%s", "LLU;");
2497025119 printf("%s", "\n label = ");
2497125120 // call printnr from ProcCall
24972- stack[base + 32LLU] = 2013LLU/*throw to this address*/;
24973- stack[base + 33LLU] = base;
24974- stack[base + 34LLU] = 2014LLU;
25121+ stack[base + 34LLU] = 2027LLU/*throw to this address*/;
25122+ stack[base + 35LLU] = base;
25123+ stack[base + 36LLU] = 2028LLU;
2497525124 // arguments for call to printnr
24976- stack[base + 35LLU] = stack[base + 19]/*celabel*/;
25125+ stack[base + 37LLU] = stack[base + 20]/*celabel*/;
2497725126 // set stack-base & callee-address
24978- base += 35LLU;
25127+ base += 37LLU;
2497925128 label = 18446744073709551590LLU; // printnr
2498025129 break;
2498125130 }
24982- case 2013LLU: // copy-back deleter (printnr to ProcCall)
25131+ case 2027LLU: // copy-back deleter (printnr to ProcCall)
2498325132 {
2498425133 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2498525134 // copy mutable arguments back from call to printnr
24986- label = 1836LLU; // continue to roll stack
25135+ label = 1850LLU; // continue to roll stack
2498725136 break;
2498825137 }
24989- case 2014LLU: // return from printnr to ProcCall
25138+ case 2028LLU: // return from printnr to ProcCall
2499025139 {
2499125140 // copy mutable arguments back from call to printnr
2499225141 printf("%s", "LLU; // ");
2499325142 // call printid from ProcCall
24994- stack[base + 32LLU] = 2015LLU/*throw to this address*/;
24995- stack[base + 33LLU] = base;
24996- stack[base + 34LLU] = 2016LLU;
25143+ stack[base + 34LLU] = 2029LLU/*throw to this address*/;
25144+ stack[base + 35LLU] = base;
25145+ stack[base + 36LLU] = 2030LLU;
2499725146 // arguments for call to printid
24998- stack[base + 35LLU] = stack[base + 23]/*ceid*/;
25147+ stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2499925148 // set stack-base & callee-address
25000- base += 35LLU;
25149+ base += 37LLU;
2500125150 label = 18446744073709551587LLU; // printid
2500225151 break;
2500325152 }
25004- case 2015LLU: // copy-back deleter (printid to ProcCall)
25153+ case 2029LLU: // copy-back deleter (printid to ProcCall)
2500525154 {
2500625155 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2500725156 // copy mutable arguments back from call to printid
25008- label = 1836LLU; // continue to roll stack
25157+ label = 1850LLU; // continue to roll stack
2500925158 break;
2501025159 }
25011- case 2016LLU: // return from printid to ProcCall
25160+ case 2030LLU: // return from printid to ProcCall
2501225161 {
2501325162 // copy mutable arguments back from call to printid
2501425163 printf("%s", "\n break;");
@@ -25015,78 +25164,78 @@
2501525164 printf("%s", "\n }");
2501625165 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2501725166 {
25018- label = 2018LLU; // jump to alternative
25167+ label = 2032LLU; // jump to alternative
2501925168 break;
2502025169 }
2502125170
25022- /*labelthrow*/stack[base + 32] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/;
25023- /*dummy*/stack[base + 33] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/;
25171+ /*labelthrow*/stack[base + 34] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/;
25172+ /*dummy*/stack[base + 35] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/;
2502425173
2502525174 // case
2502625175 printf("%s", "\n case ");
2502725176 // call printnr from ProcCall
25028- stack[base + 34LLU] = 2019LLU/*throw to this address*/;
25029- stack[base + 35LLU] = base;
25030- stack[base + 36LLU] = 2020LLU;
25177+ stack[base + 36LLU] = 2033LLU/*throw to this address*/;
25178+ stack[base + 37LLU] = base;
25179+ stack[base + 38LLU] = 2034LLU;
2503125180 // arguments for call to printnr
25032- stack[base + 37LLU] = stack[base + 31]/*labelfail*/;
25181+ stack[base + 39LLU] = stack[base + 33]/*labelfail*/;
2503325182 // set stack-base & callee-address
25034- base += 37LLU;
25183+ base += 39LLU;
2503525184 label = 18446744073709551590LLU; // printnr
2503625185 break;
2503725186 }
25038- case 2019LLU: // copy-back deleter (printnr to ProcCall)
25187+ case 2033LLU: // copy-back deleter (printnr to ProcCall)
2503925188 {
2504025189 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2504125190 // copy mutable arguments back from call to printnr
25042- label = 1836LLU; // continue to roll stack
25191+ label = 1850LLU; // continue to roll stack
2504325192 break;
2504425193 }
25045- case 2020LLU: // return from printnr to ProcCall
25194+ case 2034LLU: // return from printnr to ProcCall
2504625195 {
2504725196 // copy mutable arguments back from call to printnr
2504825197 printf("%s", "LLU: // copy-back deleter (");
2504925198 // call printid from ProcCall
25050- stack[base + 34LLU] = 2021LLU/*throw to this address*/;
25051- stack[base + 35LLU] = base;
25052- stack[base + 36LLU] = 2022LLU;
25199+ stack[base + 36LLU] = 2035LLU/*throw to this address*/;
25200+ stack[base + 37LLU] = base;
25201+ stack[base + 38LLU] = 2036LLU;
2505325202 // arguments for call to printid
25054- stack[base + 37LLU] = stack[base + 23]/*ceid*/;
25203+ stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2505525204 // set stack-base & callee-address
25056- base += 37LLU;
25205+ base += 39LLU;
2505725206 label = 18446744073709551587LLU; // printid
2505825207 break;
2505925208 }
25060- case 2021LLU: // copy-back deleter (printid to ProcCall)
25209+ case 2035LLU: // copy-back deleter (printid to ProcCall)
2506125210 {
2506225211 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2506325212 // copy mutable arguments back from call to printid
25064- label = 1836LLU; // continue to roll stack
25213+ label = 1850LLU; // continue to roll stack
2506525214 break;
2506625215 }
25067- case 2022LLU: // return from printid to ProcCall
25216+ case 2036LLU: // return from printid to ProcCall
2506825217 {
2506925218 // copy mutable arguments back from call to printid
2507025219 printf("%s", " to ");
2507125220 // call printid from ProcCall
25072- stack[base + 34LLU] = 2023LLU/*throw to this address*/;
25073- stack[base + 35LLU] = base;
25074- stack[base + 36LLU] = 2024LLU;
25221+ stack[base + 36LLU] = 2037LLU/*throw to this address*/;
25222+ stack[base + 37LLU] = base;
25223+ stack[base + 38LLU] = 2038LLU;
2507525224 // arguments for call to printid
25076- stack[base + 37LLU] = stack[base + 7]/*fnid*/;
25225+ stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2507725226 // set stack-base & callee-address
25078- base += 37LLU;
25227+ base += 39LLU;
2507925228 label = 18446744073709551587LLU; // printid
2508025229 break;
2508125230 }
25082- case 2023LLU: // copy-back deleter (printid to ProcCall)
25231+ case 2037LLU: // copy-back deleter (printid to ProcCall)
2508325232 {
2508425233 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2508525234 // copy mutable arguments back from call to printid
25086- label = 1836LLU; // continue to roll stack
25235+ label = 1850LLU; // continue to roll stack
2508725236 break;
2508825237 }
25089- case 2024LLU: // return from printid to ProcCall
25238+ case 2038LLU: // return from printid to ProcCall
2509025239 {
2509125240 // copy mutable arguments back from call to printid
2509225241 printf("%s", ")");
@@ -25093,68 +25242,68 @@
2509325242 printf("%s", "\n {");
2509425243 printf("%s", "\n fprintf(stderr, \"in function ");
2509525244 // call printid from ProcCall
25096- stack[base + 34LLU] = 2025LLU/*throw to this address*/;
25097- stack[base + 35LLU] = base;
25098- stack[base + 36LLU] = 2026LLU;
25245+ stack[base + 36LLU] = 2039LLU/*throw to this address*/;
25246+ stack[base + 37LLU] = base;
25247+ stack[base + 38LLU] = 2040LLU;
2509925248 // arguments for call to printid
25100- stack[base + 37LLU] = stack[base + 7]/*fnid*/;
25249+ stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2510125250 // set stack-base & callee-address
25102- base += 37LLU;
25251+ base += 39LLU;
2510325252 label = 18446744073709551587LLU; // printid
2510425253 break;
2510525254 }
25106- case 2025LLU: // copy-back deleter (printid to ProcCall)
25255+ case 2039LLU: // copy-back deleter (printid to ProcCall)
2510725256 {
2510825257 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2510925258 // copy mutable arguments back from call to printid
25110- label = 1836LLU; // continue to roll stack
25259+ label = 1850LLU; // continue to roll stack
2511125260 break;
2511225261 }
25113- case 2026LLU: // return from printid to ProcCall
25262+ case 2040LLU: // return from printid to ProcCall
2511425263 {
2511525264 // copy mutable arguments back from call to printid
2511625265 printf("%s", ": unrolling stack, copy-back (");
2511725266 // call printid from ProcCall
25118- stack[base + 34LLU] = 2027LLU/*throw to this address*/;
25119- stack[base + 35LLU] = base;
25120- stack[base + 36LLU] = 2028LLU;
25267+ stack[base + 36LLU] = 2041LLU/*throw to this address*/;
25268+ stack[base + 37LLU] = base;
25269+ stack[base + 38LLU] = 2042LLU;
2512125270 // arguments for call to printid
25122- stack[base + 37LLU] = stack[base + 23]/*ceid*/;
25271+ stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2512325272 // set stack-base & callee-address
25124- base += 37LLU;
25273+ base += 39LLU;
2512525274 label = 18446744073709551587LLU; // printid
2512625275 break;
2512725276 }
25128- case 2027LLU: // copy-back deleter (printid to ProcCall)
25277+ case 2041LLU: // copy-back deleter (printid to ProcCall)
2512925278 {
2513025279 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2513125280 // copy mutable arguments back from call to printid
25132- label = 1836LLU; // continue to roll stack
25281+ label = 1850LLU; // continue to roll stack
2513325282 break;
2513425283 }
25135- case 2028LLU: // return from printid to ProcCall
25284+ case 2042LLU: // return from printid to ProcCall
2513625285 {
2513725286 // copy mutable arguments back from call to printid
2513825287 printf("%s", " to ");
2513925288 // call printid from ProcCall
25140- stack[base + 34LLU] = 2029LLU/*throw to this address*/;
25141- stack[base + 35LLU] = base;
25142- stack[base + 36LLU] = 2030LLU;
25289+ stack[base + 36LLU] = 2043LLU/*throw to this address*/;
25290+ stack[base + 37LLU] = base;
25291+ stack[base + 38LLU] = 2044LLU;
2514325292 // arguments for call to printid
25144- stack[base + 37LLU] = stack[base + 7]/*fnid*/;
25293+ stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2514525294 // set stack-base & callee-address
25146- base += 37LLU;
25295+ base += 39LLU;
2514725296 label = 18446744073709551587LLU; // printid
2514825297 break;
2514925298 }
25150- case 2029LLU: // copy-back deleter (printid to ProcCall)
25299+ case 2043LLU: // copy-back deleter (printid to ProcCall)
2515125300 {
2515225301 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2515325302 // copy mutable arguments back from call to printid
25154- label = 1836LLU; // continue to roll stack
25303+ label = 1850LLU; // continue to roll stack
2515525304 break;
2515625305 }
25157- case 2030LLU: // return from printid to ProcCall
25306+ case 2044LLU: // return from printid to ProcCall
2515825307 {
2515925308 // copy mutable arguments back from call to printid
2516025309 printf("%s", ")");
@@ -25161,339 +25310,339 @@
2516125310 printf("%s", "\\n\");");
2516225311 printf("%s", "\n // copy mutable arguments back from call to ");
2516325312 // call printid from ProcCall
25164- stack[base + 34LLU] = 2031LLU/*throw to this address*/;
25165- stack[base + 35LLU] = base;
25166- stack[base + 36LLU] = 2032LLU;
25313+ stack[base + 36LLU] = 2045LLU/*throw to this address*/;
25314+ stack[base + 37LLU] = base;
25315+ stack[base + 38LLU] = 2046LLU;
2516725316 // arguments for call to printid
25168- stack[base + 37LLU] = stack[base + 23]/*ceid*/;
25317+ stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2516925318 // set stack-base & callee-address
25170- base += 37LLU;
25319+ base += 39LLU;
2517125320 label = 18446744073709551587LLU; // printid
2517225321 break;
2517325322 }
25174- case 2031LLU: // copy-back deleter (printid to ProcCall)
25323+ case 2045LLU: // copy-back deleter (printid to ProcCall)
2517525324 {
2517625325 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2517725326 // copy mutable arguments back from call to printid
25178- label = 1836LLU; // continue to roll stack
25327+ label = 1850LLU; // continue to roll stack
2517925328 break;
2518025329 }
25181- case 2032LLU: // return from printid to ProcCall
25330+ case 2046LLU: // return from printid to ProcCall
2518225331 {
2518325332 // copy mutable arguments back from call to printid
25184- flippedassign(stack[base + 18]/*copyback*/, &stack[base + 34]);
25185- label = 2033LLU; // start to repeat
25333+ flippedassign(stack[base + 19]/*copyback*/, &stack[base + 36]);
25334+ label = 2047LLU; // start to repeat
2518625335 break;
2518725336 }
25188- case 2033LLU: // repeat from here
25337+ case 2047LLU: // repeat from here
2518925338 {
25190- if(!stack[base + 34])
25339+ if(!stack[base + 36])
2519125340 {
25192- label = 2034LLU; // break loop
25341+ label = 2048LLU; // break loop
2519325342 break;
2519425343 }
2519525344
2519625345 // loop body
25197- stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data);
25198- stack[base + 36]/*previous*/ = stack[base + 34];
25199- stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
25200- if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0])
25346+ stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->data);
25347+ stack[base + 38]/*previous*/ = stack[base + 36];
25348+ stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
25349+ if(/*idnr*/0 != ((uint64_t *)(stack[base + 37]/*idnr*/))[0])
2520125350 {
25202- label = 2036LLU; // jump to alternative
25351+ label = 2050LLU; // jump to alternative
2520325352 break;
2520425353 }
2520525354
25206- /*content*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][0]/*id*/;
25207- /*sum*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][1]/*nr*/;
25355+ /*content*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*idnr*/))[1][0]/*id*/;
25356+ /*sum*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*idnr*/))[1][1]/*nr*/;
2520825357
2520925358 // case
2521025359 printf("%s", "\n ");
2521125360 // call emitvar from ProcCall
25212- stack[base + 39LLU] = 2037LLU/*throw to this address*/;
25213- stack[base + 40LLU] = base;
25214- stack[base + 41LLU] = 2038LLU;
25361+ stack[base + 41LLU] = 2051LLU/*throw to this address*/;
25362+ stack[base + 42LLU] = base;
25363+ stack[base + 43LLU] = 2052LLU;
2521525364 // arguments for call to emitvar
25216- stack[base + 42LLU] = stack[base + 7]/*fnid*/;
25217- stack[base + 43LLU] = stack[base + 37]/*content*/;
25218- stack[base + 44LLU] = stack[base + 2]/*scopes*/;
25219- stack[base + 45LLU] = stack[base + 3]/*scope*/;
25365+ stack[base + 44LLU] = stack[base + 8]/*fnid*/;
25366+ stack[base + 45LLU] = stack[base + 39]/*content*/;
25367+ stack[base + 46LLU] = stack[base + 2]/*scopes*/;
25368+ stack[base + 47LLU] = stack[base + 3]/*scope*/;
2522025369 // set stack-base & callee-address
25221- base += 42LLU;
25370+ base += 44LLU;
2522225371 label = 659LLU; // emitvar
2522325372 break;
2522425373 }
25225- case 2037LLU: // copy-back deleter (emitvar to ProcCall)
25374+ case 2051LLU: // copy-back deleter (emitvar to ProcCall)
2522625375 {
2522725376 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2522825377 // copy mutable arguments back from call to emitvar
25229- label = 1836LLU; // continue to roll stack
25378+ label = 1850LLU; // continue to roll stack
2523025379 break;
2523125380 }
25232- case 2038LLU: // return from emitvar to ProcCall
25381+ case 2052LLU: // return from emitvar to ProcCall
2523325382 {
2523425383 // copy mutable arguments back from call to emitvar
2523525384 printf("%s", " = stack[base + ");
2523625385 // call printnr from ProcCall
25237- stack[base + 39LLU] = 2039LLU/*throw to this address*/;
25238- stack[base + 40LLU] = base;
25239- stack[base + 41LLU] = 2040LLU;
25386+ stack[base + 41LLU] = 2053LLU/*throw to this address*/;
25387+ s

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

Show on old repository browser