• R/O
  • SSH
  • HTTPS

jpl: 提交


Commit MetaInfo

修订版927 (tree)
时间2020-02-13 02:01:09
作者jakobthomsen

Log Message

fix defining function without parameters in new syntax

更改概述

差异

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 926)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 927)
@@ -89173,6 +89173,7 @@
8917389173 case 18446744073709546310LLU: // 99999998rF'''''''''''''''
8917489174 {
8917589175 /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) = (uint64_t)getchar();
89176+ /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) = (uint64_t)getchar();
8917689177 heap.availilable_size_for_dynamic_objects += 0LLU;
8917789178 heap.availilable_size_for_dynamic_objects += 0LLU;
8917889179 state.addr = 18446744073709546308LLU; // 99999998rD'''''''''''''''
@@ -96420,6 +96421,46 @@
9642096421 }
9642196422 case 18446744073709545977LLU: // 99999998l3'''''''''''''''
9642296423 {
96424+ state.addr = /*parnr_____*/*LOCAL_ACCESS(heap.data, 33LLU, 32LLU) ? 18446744073709545794LLU : 18446744073709545793LLU;
96425+ break;
96426+ }
96427+ case 18446744073709545794LLU: // 99999998jB'''''''''''''''
96428+ {
96429+ heap.availilable_size_for_dynamic_objects += 0LLU;
96430+ heap.availilable_size_for_dynamic_objects += 0LLU;
96431+ state.addr = 18446744073709545792LLU; // 99999998j_'''''''''''''''
96432+ break;
96433+ }
96434+ case 18446744073709545793LLU: // 99999998jA'''''''''''''''
96435+ {
96436+ // ACCUMULATE ARGUMENTS - BEGIN
96437+ {
96438+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 33LLU, 4LLU);
96439+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
96440+ }
96441+ // ACCUMULATE ARGUMENTS - END
96442+ uint64_t return_to = 18446744073709545790LLU;
96443+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
96444+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
96445+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
96446+ heap.data[0].elem1 = heap.data[0].elem0;
96447+ heap.data[0].elem0 = restore;
96448+ state.addr = 839519719621918720LLU; // skipws____
96449+ break;
96450+ }
96451+ case 18446744073709545790LLU: // 99999998i8'''''''''''''''
96452+ {
96453+ state.addr = 18446744073709545791LLU; // 99999998i9'''''''''''''''
96454+ break;
96455+ }
96456+ case 18446744073709545791LLU: // 99999998i9'''''''''''''''
96457+ {
96458+ matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)));
96459+ state.addr = 18446744073709545792LLU; // 99999998j_'''''''''''''''
96460+ break;
96461+ }
96462+ case 18446744073709545792LLU: // 99999998j_'''''''''''''''
96463+ {
9642396464 {
9642496465 uint64_t arg = 0LLU;
9642596466 LOCAL_PUSH_MOVE(&heap, 33, &(heap.data[0].elem1)/*address of current closure*/, &arg);
@@ -96429,10 +96470,10 @@
9642996470 // variable u64 argscount_ goes out of scope
9643096471 // emitted destructur for type u64
9643196472 (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference argscount_ at 34
96432- state.addr = 18446744073709545794LLU; // 99999998jB'''''''''''''''
96473+ state.addr = 18446744073709545789LLU; // 99999998i7'''''''''''''''
9643396474 break;
9643496475 }
96435- case 18446744073709545794LLU: // 99999998jB'''''''''''''''
96476+ case 18446744073709545789LLU: // 99999998i7'''''''''''''''
9643696477 {
9643796478 // ACCUMULATE ARGUMENTS - BEGIN
9643896479 {
@@ -96440,7 +96481,7 @@
9644096481 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9644196482 }
9644296483 // ACCUMULATE ARGUMENTS - END
96443- uint64_t return_to = 18446744073709545792LLU;
96484+ uint64_t return_to = 18446744073709545787LLU;
9644496485 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9644596486 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9644696487 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96449,12 +96490,12 @@
9644996490 state.addr = 839519719621918720LLU; // skipws____
9645096491 break;
9645196492 }
96452- case 18446744073709545792LLU: // 99999998j_'''''''''''''''
96493+ case 18446744073709545787LLU: // 99999998i5'''''''''''''''
9645396494 {
96454- state.addr = 18446744073709545793LLU; // 99999998jA'''''''''''''''
96495+ state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
9645596496 break;
9645696497 }
96457- case 18446744073709545793LLU: // 99999998jA'''''''''''''''
96498+ case 18446744073709545788LLU: // 99999998i6'''''''''''''''
9645896499 {
9645996500 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)));
9646096501 // ACCUMULATE ARGUMENTS - BEGIN
@@ -96463,7 +96504,7 @@
9646396504 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9646496505 }
9646596506 // ACCUMULATE ARGUMENTS - END
96466- uint64_t return_to = 18446744073709545790LLU;
96507+ uint64_t return_to = 18446744073709545785LLU;
9646796508 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9646896509 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9646996510 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96472,12 +96513,12 @@
9647296513 state.addr = 839519719621918720LLU; // skipws____
9647396514 break;
9647496515 }
96475- case 18446744073709545790LLU: // 99999998i8'''''''''''''''
96516+ case 18446744073709545785LLU: // 99999998i3'''''''''''''''
9647696517 {
96477- state.addr = 18446744073709545791LLU; // 99999998i9'''''''''''''''
96518+ state.addr = 18446744073709545786LLU; // 99999998i4'''''''''''''''
9647896519 break;
9647996520 }
96480- case 18446744073709545791LLU: // 99999998i9'''''''''''''''
96521+ case 18446744073709545786LLU: // 99999998i4'''''''''''''''
9648196522 {
9648296523 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)), stdin);
9648396524 if('{' != (char)getchar())
@@ -96485,15 +96526,15 @@
9648596526 fprintf(stderr, "match failed at char %c\n", (char)123LLU);
9648696527 exit(-1);
9648796528 }
96488- state.addr = 18446744073709545789LLU; // 99999998i7'''''''''''''''
96529+ state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
9648996530 break;
9649096531 }
96491- case 18446744073709545789LLU: // 99999998i7'''''''''''''''
96532+ case 18446744073709545784LLU: // 99999998i2'''''''''''''''
9649296533 {
9649396534 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)) = (uint64_t)getchar();
9649496535 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)) > 255)
9649596536 {
96496- state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
96537+ state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
9649796538 break;
9649896539 }
9649996540 // ACCUMULATE ARGUMENTS - BEGIN
@@ -96562,7 +96603,7 @@
9656296603 LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9656396604 }
9656496605 // ACCUMULATE ARGUMENTS - END
96565- uint64_t return_to = 18446744073709545786LLU;
96606+ uint64_t return_to = 18446744073709545781LLU;
9656696607 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0));
9656796608 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9656896609 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96571,31 +96612,31 @@
9657196612 state.addr = 782701543301228454LLU; // parseblock
9657296613 break;
9657396614 }
96574- case 18446744073709545786LLU: // 99999998i4'''''''''''''''
96615+ case 18446744073709545781LLU: // 99999998iz'''''''''''''''
9657596616 {
96576- state.addr = 18446744073709545787LLU; // 99999998i5'''''''''''''''
96617+ state.addr = 18446744073709545782LLU; // 99999998i0'''''''''''''''
9657796618 break;
9657896619 }
96579- case 18446744073709545787LLU: // 99999998i5'''''''''''''''
96620+ case 18446744073709545782LLU: // 99999998i0'''''''''''''''
9658096621 {
96581- state.addr = 18446744073709545789LLU; // 99999998i7'''''''''''''''
96622+ state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
9658296623 break;
9658396624 }
96584- case 18446744073709545788LLU: // 99999998i6'''''''''''''''
96625+ case 18446744073709545783LLU: // 99999998i1'''''''''''''''
9658596626 {
96586- state.addr = /*varlist___*/*LOCAL_ACCESS(heap.data, 33LLU, 27LLU) ? 18446744073709545785LLU : 18446744073709545784LLU;
96627+ state.addr = /*varlist___*/*LOCAL_ACCESS(heap.data, 33LLU, 27LLU) ? 18446744073709545780LLU : 18446744073709545779LLU;
9658796628 break;
9658896629 }
96589- case 18446744073709545785LLU: // 99999998i3'''''''''''''''
96630+ case 18446744073709545780LLU: // 99999998iy'''''''''''''''
9659096631 {
9659196632 {
9659296633 fprintf(stderr, "%s\n", "INTERNAL ERROR: varlist not empty at end of definition\n");
9659396634 exit(-1);
9659496635 }
96595- state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
96636+ state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
9659696637 break;
9659796638 }
96598- case 18446744073709545784LLU: // 99999998i2'''''''''''''''
96639+ case 18446744073709545779LLU: // 99999998ix'''''''''''''''
9659996640 {
9660096641 {
9660196642 uint64_t arg = /*results___*/*LOCAL_ACCESS(heap.data, 33LLU, 21LLU);
@@ -96605,10 +96646,10 @@
9660596646 uint64_t arg = 0;
9660696647 LOCAL_PUSH_MOVE(&heap, 34, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9660796648 }
96608- state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
96649+ state.addr = 18446744073709545778LLU; // 99999998iw'''''''''''''''
9660996650 break;
9661096651 }
96611- case 18446744073709545783LLU: // 99999998i1'''''''''''''''
96652+ case 18446744073709545778LLU: // 99999998iw'''''''''''''''
9661296653 {
9661396654 if(!*LOCAL_ACCESS(heap.data, 35LLU, 33LLU))
9661496655 {
@@ -96615,7 +96656,7 @@
9661596656 (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 35
9661696657 (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 34
9661796658 {
96618- state.addr = 18446744073709545782LLU; // 99999998i0'''''''''''''''
96659+ state.addr = 18446744073709545777LLU; // 99999998iv'''''''''''''''
9661996660 break;
9662096661 }
9662196662 }
@@ -96643,7 +96684,7 @@
9664396684 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9664496685 }
9664596686 // ACCUMULATE ARGUMENTS - END
96646- uint64_t return_to = 18446744073709545780LLU;
96687+ uint64_t return_to = 18446744073709545775LLU;
9664796688 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9664896689 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9664996690 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96652,12 +96693,12 @@
9665296693 state.addr = 587881357748656161LLU; // emitpopref
9665396694 break;
9665496695 }
96655- case 18446744073709545780LLU: // 99999998iy'''''''''''''''
96696+ case 18446744073709545775LLU: // 99999998it'''''''''''''''
9665696697 {
96657- state.addr = 18446744073709545781LLU; // 99999998iz'''''''''''''''
96698+ state.addr = 18446744073709545776LLU; // 99999998iu'''''''''''''''
9665896699 break;
9665996700 }
96660- case 18446744073709545781LLU: // 99999998iz'''''''''''''''
96701+ case 18446744073709545776LLU: // 99999998iu'''''''''''''''
9666196702 {
9666296703 // variable u64 resultid__ goes out of scope
9666396704 // emitted destructur for type u64
@@ -96664,10 +96705,10 @@
9666496705 (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultid__ at 36
9666596706 // parameter-reference resdest___ respar____ goes out of scope
9666696707 // parameter list<resdest___> results___ goes out of scope
96667- state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
96708+ state.addr = 18446744073709545778LLU; // 99999998iw'''''''''''''''
9666896709 break;
9666996710 }
96670- case 18446744073709545782LLU: // 99999998i0'''''''''''''''
96711+ case 18446744073709545777LLU: // 99999998iv'''''''''''''''
9667196712 {
9667296713 // ACCUMULATE ARGUMENTS - BEGIN
9667396714 {
@@ -96683,7 +96724,7 @@
9668396724 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9668496725 }
9668596726 // ACCUMULATE ARGUMENTS - END
96686- uint64_t return_to = 18446744073709545778LLU;
96727+ uint64_t return_to = 18446744073709545773LLU;
9668796728 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9668896729 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9668996730 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96692,12 +96733,12 @@
9669296733 state.addr = 587881353282000896LLU; // emitleave_
9669396734 break;
9669496735 }
96695- case 18446744073709545778LLU: // 99999998iw'''''''''''''''
96736+ case 18446744073709545773LLU: // 99999998ir'''''''''''''''
9669696737 {
96697- state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
96738+ state.addr = 18446744073709545774LLU; // 99999998is'''''''''''''''
9669896739 break;
9669996740 }
96700- case 18446744073709545779LLU: // 99999998ix'''''''''''''''
96741+ case 18446744073709545774LLU: // 99999998is'''''''''''''''
9670196742 {
9670296743 // variable u64 parnr_____ goes out of scope
9670396744 // emitted destructur for type u64
@@ -96713,14 +96754,14 @@
9671396754 (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference returnbase at 30
9671496755 // variable list<u64_______> redefcheck goes out of scope
9671596756 // emitted destructur for type list<u64_______>
96716- state.addr = 18446744073709545776LLU; // 99999998iu'''''''''''''''
96757+ state.addr = 18446744073709545771LLU; // 99999998ip'''''''''''''''
9671796758 break;
9671896759 }
96719- case 18446744073709545776LLU: // 99999998iu'''''''''''''''
96760+ case 18446744073709545771LLU: // 99999998ip'''''''''''''''
9672096761 {
9672196762 if(!*LOCAL_ACCESS(heap.data, 29LLU, 28LLU)/*list*/)
9672296763 {
96723- state.addr = 18446744073709545777LLU; // 99999998iv'''''''''''''''
96764+ state.addr = 18446744073709545772LLU; // 99999998iq'''''''''''''''
9672496765 break;
9672596766 }
9672696767 // temporary list-element
@@ -96730,10 +96771,10 @@
9673096771 }
9673196772 // RELEASE temporary destructor-variable
9673296773 (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 30
96733- state.addr = 18446744073709545776LLU; // 99999998iu'''''''''''''''
96774+ state.addr = 18446744073709545771LLU; // 99999998ip'''''''''''''''
9673496775 break;
9673596776 }
96736- case 18446744073709545777LLU: // 99999998iv'''''''''''''''
96777+ case 18446744073709545772LLU: // 99999998iq'''''''''''''''
9673796778 {
9673896779 (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference redefcheck at 29
9673996780 state.addr = 18446744073709545983LLU; // 99999998l9'''''''''''''''
@@ -96743,14 +96784,14 @@
9674396784 {
9674496785 // variable list<varentry__> varlist___ goes out of scope
9674596786 // emitted destructur for type list<varentry__>
96746- state.addr = 18446744073709545774LLU; // 99999998is'''''''''''''''
96787+ state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
9674796788 break;
9674896789 }
96749- case 18446744073709545774LLU: // 99999998is'''''''''''''''
96790+ case 18446744073709545769LLU: // 99999998in'''''''''''''''
9675096791 {
9675196792 if(!*LOCAL_ACCESS(heap.data, 28LLU, 27LLU)/*list*/)
9675296793 {
96753- state.addr = 18446744073709545775LLU; // 99999998it'''''''''''''''
96794+ state.addr = 18446744073709545770LLU; // 99999998io'''''''''''''''
9675496795 break;
9675596796 }
9675696797 // temporary list-element
@@ -96764,7 +96805,7 @@
9676496805 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9676596806 }
9676696807 // ACCUMULATE ARGUMENTS - END
96767- uint64_t return_to = 18446744073709545773LLU;
96808+ uint64_t return_to = 18446744073709545768LLU;
9676896809 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9676996810 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9677096811 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96773,14 +96814,14 @@
9677396814 state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
9677496815 break;
9677596816 }
96776- case 18446744073709545773LLU: // 99999998ir'''''''''''''''
96817+ case 18446744073709545768LLU: // 99999998im'''''''''''''''
9677796818 {
9677896819 // RELEASE temporary destructor-variable
9677996820 (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 29
96780- state.addr = 18446744073709545774LLU; // 99999998is'''''''''''''''
96821+ state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
9678196822 break;
9678296823 }
96783- case 18446744073709545775LLU: // 99999998it'''''''''''''''
96824+ case 18446744073709545770LLU: // 99999998io'''''''''''''''
9678496825 {
9678596826 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varlist___ at 28
9678696827 // variable u64 matchsym__ goes out of scope
@@ -96800,14 +96841,14 @@
9680096841 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defargcnt_ at 23
9680196842 // variable list<resdest___> results___ goes out of scope
9680296843 // emitted destructur for type list<resdest___>
96803- state.addr = 18446744073709545771LLU; // 99999998ip'''''''''''''''
96844+ state.addr = 18446744073709545766LLU; // 99999998ik'''''''''''''''
9680496845 break;
9680596846 }
96806- case 18446744073709545771LLU: // 99999998ip'''''''''''''''
96847+ case 18446744073709545766LLU: // 99999998ik'''''''''''''''
9680796848 {
9680896849 if(!*LOCAL_ACCESS(heap.data, 22LLU, 21LLU)/*list*/)
9680996850 {
96810- state.addr = 18446744073709545772LLU; // 99999998iq'''''''''''''''
96851+ state.addr = 18446744073709545767LLU; // 99999998il'''''''''''''''
9681196852 break;
9681296853 }
9681396854 // temporary list-element
@@ -96821,7 +96862,7 @@
9682196862 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9682296863 }
9682396864 // ACCUMULATE ARGUMENTS - END
96824- uint64_t return_to = 18446744073709545770LLU;
96865+ uint64_t return_to = 18446744073709545765LLU;
9682596866 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9682696867 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9682796868 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96830,14 +96871,14 @@
9683096871 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
9683196872 break;
9683296873 }
96833- case 18446744073709545770LLU: // 99999998io'''''''''''''''
96874+ case 18446744073709545765LLU: // 99999998ij'''''''''''''''
9683496875 {
9683596876 // RELEASE temporary destructor-variable
9683696877 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
96837- state.addr = 18446744073709545771LLU; // 99999998ip'''''''''''''''
96878+ state.addr = 18446744073709545766LLU; // 99999998ik'''''''''''''''
9683896879 break;
9683996880 }
96840- case 18446744073709545772LLU: // 99999998iq'''''''''''''''
96881+ case 18446744073709545767LLU: // 99999998il'''''''''''''''
9684196882 {
9684296883 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 22
9684396884 // parameter-reference u64 remainheap goes out of scope
@@ -96902,7 +96943,7 @@
9690296943 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9690396944 }
9690496945 // ACCUMULATE ARGUMENTS - END
96905- uint64_t return_to = 18446744073709545768LLU;
96946+ uint64_t return_to = 18446744073709545763LLU;
9690696947 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9690796948 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9690896949 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96911,12 +96952,12 @@
9691196952 state.addr = 839519719621918720LLU; // skipws____
9691296953 break;
9691396954 }
96914- case 18446744073709545768LLU: // 99999998im'''''''''''''''
96955+ case 18446744073709545763LLU: // 99999998ih'''''''''''''''
9691596956 {
96916- state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
96957+ state.addr = 18446744073709545764LLU; // 99999998ii'''''''''''''''
9691796958 break;
9691896959 }
96919- case 18446744073709545769LLU: // 99999998in'''''''''''''''
96960+ case 18446744073709545764LLU: // 99999998ii'''''''''''''''
9692096961 {
9692196962 // ACCUMULATE ARGUMENTS - BEGIN
9692296963 {
@@ -96928,7 +96969,7 @@
9692896969 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9692996970 }
9693096971 // ACCUMULATE ARGUMENTS - END
96931- uint64_t return_to = 18446744073709545766LLU;
96972+ uint64_t return_to = 18446744073709545761LLU;
9693296973 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
9693396974 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9693496975 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96937,17 +96978,17 @@
9693796978 state.addr = 661649452408901632LLU; // isnoteof__
9693896979 break;
9693996980 }
96940- case 18446744073709545766LLU: // 99999998ik'''''''''''''''
96981+ case 18446744073709545761LLU: // 99999998if'''''''''''''''
9694196982 {
96942- state.addr = 18446744073709545767LLU; // 99999998il'''''''''''''''
96983+ state.addr = 18446744073709545762LLU; // 99999998ig'''''''''''''''
9694396984 break;
9694496985 }
96945- case 18446744073709545767LLU: // 99999998il'''''''''''''''
96986+ case 18446744073709545762LLU: // 99999998ig'''''''''''''''
9694696987 {
96947- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545765LLU : 18446744073709545764LLU;
96988+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545760LLU : 18446744073709545759LLU;
9694896989 break;
9694996990 }
96950- case 18446744073709545765LLU: // 99999998ij'''''''''''''''
96991+ case 18446744073709545760LLU: // 99999998ie'''''''''''''''
9695196992 {
9695296993 {
9695396994 uint64_t arg = 0LLU;
@@ -96959,10 +97000,10 @@
9695997000 LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9696097001 }
9696197002 /*isstruct__*/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /*isstruct__*/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) == /*def_id____*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
96962- state.addr = /*isstruct__*/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709545763LLU : 18446744073709545762LLU;
97003+ state.addr = /*isstruct__*/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709545758LLU : 18446744073709545757LLU;
9696397004 break;
9696497005 }
96965- case 18446744073709545763LLU: // 99999998ih'''''''''''''''
97006+ case 18446744073709545758LLU: // 99999998ic'''''''''''''''
9696697007 {
9696797008 // ACCUMULATE ARGUMENTS - BEGIN
9696897009 {
@@ -96970,7 +97011,7 @@
9697097011 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9697197012 }
9697297013 // ACCUMULATE ARGUMENTS - END
96973- uint64_t return_to = 18446744073709545760LLU;
97014+ uint64_t return_to = 18446744073709545755LLU;
9697497015 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9697597016 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9697697017 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -96979,12 +97020,12 @@
9697997020 state.addr = 839519719621918720LLU; // skipws____
9698097021 break;
9698197022 }
96982- case 18446744073709545760LLU: // 99999998ie'''''''''''''''
97023+ case 18446744073709545755LLU: // 99999998i$'''''''''''''''
9698397024 {
96984- state.addr = 18446744073709545761LLU; // 99999998if'''''''''''''''
97025+ state.addr = 18446744073709545756LLU; // 99999998ia'''''''''''''''
9698597026 break;
9698697027 }
96987- case 18446744073709545761LLU: // 99999998if'''''''''''''''
97028+ case 18446744073709545756LLU: // 99999998ia'''''''''''''''
9698897029 {
9698997030 /*def_id____*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU)));
9699097031 {
@@ -97005,7 +97046,7 @@
9700597046 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9700697047 }
9700797048 // ACCUMULATE ARGUMENTS - END
97008- uint64_t return_to = 18446744073709545757LLU;
97049+ uint64_t return_to = 18446744073709545752LLU;
9700997050 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9701097051 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9701197052 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97014,17 +97055,17 @@
9701497055 state.addr = 590977518136150752LLU; // existstype
9701597056 break;
9701697057 }
97017- case 18446744073709545757LLU: // 99999998ib'''''''''''''''
97058+ case 18446744073709545752LLU: // 99999998iX'''''''''''''''
9701897059 {
97019- state.addr = 18446744073709545758LLU; // 99999998ic'''''''''''''''
97060+ state.addr = 18446744073709545753LLU; // 99999998iY'''''''''''''''
9702097061 break;
9702197062 }
97022- case 18446744073709545758LLU: // 99999998ic'''''''''''''''
97063+ case 18446744073709545753LLU: // 99999998iY'''''''''''''''
9702397064 {
97024- state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545756LLU : 18446744073709545755LLU;
97065+ state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545751LLU : 18446744073709545750LLU;
9702597066 break;
9702697067 }
97027- case 18446744073709545756LLU: // 99999998ia'''''''''''''''
97068+ case 18446744073709545751LLU: // 99999998iW'''''''''''''''
9702897069 {
9702997070 fprintf(stderr, "%s", "re-definition of struct ");
9703097071 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU));
@@ -97032,18 +97073,18 @@
9703297073 fprintf(stderr, "%s\n", "");
9703397074 exit(-1);
9703497075 }
97035- state.addr = 18446744073709545755LLU; // 99999998i$'''''''''''''''
97076+ state.addr = 18446744073709545750LLU; // 99999998iV'''''''''''''''
9703697077 break;
9703797078 }
97038- case 18446744073709545755LLU: // 99999998i$'''''''''''''''
97079+ case 18446744073709545750LLU: // 99999998iV'''''''''''''''
9703997080 {
9704097081 // variable u64 exists____ goes out of scope
9704197082 // emitted destructur for type u64
9704297083 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference exists____ at 10
97043- state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
97084+ state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
9704497085 break;
9704597086 }
97046- case 18446744073709545759LLU: // 99999998id'''''''''''''''
97087+ case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
9704797088 {
9704897089 {
9704997090 uint64_t arg = 0LLU;
@@ -97067,7 +97108,7 @@
9706797108 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9706897109 }
9706997110 // ACCUMULATE ARGUMENTS - END
97070- uint64_t return_to = 18446744073709545753LLU;
97111+ uint64_t return_to = 18446744073709545748LLU;
9707197112 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9707297113 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9707397114 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97076,12 +97117,12 @@
9707697117 state.addr = 782701543351519790LLU; // parseelems
9707797118 break;
9707897119 }
97079- case 18446744073709545753LLU: // 99999998iY'''''''''''''''
97120+ case 18446744073709545748LLU: // 99999998iT'''''''''''''''
9708097121 {
97081- state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
97122+ state.addr = 18446744073709545749LLU; // 99999998iU'''''''''''''''
9708297123 break;
9708397124 }
97084- case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
97125+ case 18446744073709545749LLU: // 99999998iU'''''''''''''''
9708597126 {
9708697127 {
9708797128 uint64_t arg = 0LLU;
@@ -97101,7 +97142,7 @@
9710197142 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9710297143 }
9710397144 // ACCUMULATE ARGUMENTS - END
97104- uint64_t return_to = 18446744073709545750LLU;
97145+ uint64_t return_to = 18446744073709545745LLU;
9710597146 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9710697147 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9710797148 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97110,12 +97151,12 @@
9711097151 state.addr = 839519719621918720LLU; // skipws____
9711197152 break;
9711297153 }
97113- case 18446744073709545750LLU: // 99999998iV'''''''''''''''
97154+ case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
9711497155 {
97115- state.addr = 18446744073709545751LLU; // 99999998iW'''''''''''''''
97156+ state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
9711697157 break;
9711797158 }
97118- case 18446744073709545751LLU: // 99999998iW'''''''''''''''
97159+ case 18446744073709545746LLU: // 99999998iR'''''''''''''''
9711997160 {
9712097161 // ACCUMULATE ARGUMENTS - BEGIN
9712197162 {
@@ -97131,7 +97172,7 @@
9713197172 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9713297173 }
9713397174 // ACCUMULATE ARGUMENTS - END
97134- uint64_t return_to = 18446744073709545748LLU;
97175+ uint64_t return_to = 18446744073709545743LLU;
9713597176 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9713697177 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9713797178 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97140,26 +97181,26 @@
9714097181 state.addr = 728666047794575267LLU; // matchoptch
9714197182 break;
9714297183 }
97143- case 18446744073709545748LLU: // 99999998iT'''''''''''''''
97184+ case 18446744073709545743LLU: // 99999998iO'''''''''''''''
9714497185 {
97145- state.addr = 18446744073709545749LLU; // 99999998iU'''''''''''''''
97186+ state.addr = 18446744073709545744LLU; // 99999998iP'''''''''''''''
9714697187 break;
9714797188 }
97148- case 18446744073709545749LLU: // 99999998iU'''''''''''''''
97189+ case 18446744073709545744LLU: // 99999998iP'''''''''''''''
9714997190 {
97150- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) ? 18446744073709545747LLU : 18446744073709545746LLU;
97191+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) ? 18446744073709545742LLU : 18446744073709545741LLU;
9715197192 break;
9715297193 }
97153- case 18446744073709545747LLU: // 99999998iS'''''''''''''''
97194+ case 18446744073709545742LLU: // 99999998iN'''''''''''''''
9715497195 {
9715597196 *LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = 0LLU;
9715697197
9715797198 heap.availilable_size_for_dynamic_objects += 0LLU;
9715897199 heap.availilable_size_for_dynamic_objects += 0LLU;
97159- state.addr = 18446744073709545745LLU; // 99999998iQ'''''''''''''''
97200+ state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
9716097201 break;
9716197202 }
97162- case 18446744073709545746LLU: // 99999998iR'''''''''''''''
97203+ case 18446744073709545741LLU: // 99999998iM'''''''''''''''
9716397204 {
9716497205 {
9716597206 uint64_t arg = 548504326530550772LLU;
@@ -97175,7 +97216,7 @@
9717597216 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9717697217 }
9717797218 // ACCUMULATE ARGUMENTS - END
97178- uint64_t return_to = 18446744073709545743LLU;
97219+ uint64_t return_to = 18446744073709545738LLU;
9717997220 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9718097221 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9718197222 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97184,19 +97225,19 @@
9718497225 state.addr = 839519719621918720LLU; // skipws____
9718597226 break;
9718697227 }
97187- case 18446744073709545743LLU: // 99999998iO'''''''''''''''
97228+ case 18446744073709545738LLU: // 99999998iJ'''''''''''''''
9718897229 {
97189- state.addr = 18446744073709545744LLU; // 99999998iP'''''''''''''''
97230+ state.addr = 18446744073709545739LLU; // 99999998iK'''''''''''''''
9719097231 break;
9719197232 }
97192- case 18446744073709545744LLU: // 99999998iP'''''''''''''''
97233+ case 18446744073709545739LLU: // 99999998iK'''''''''''''''
9719397234 {
9719497235 /*id________*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 5LLU)));
9719597236 /*result____*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 13LLU) == /*id________*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU);
97196- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU) ? 18446744073709545742LLU : 18446744073709545741LLU;
97237+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU) ? 18446744073709545737LLU : 18446744073709545736LLU;
9719797238 break;
9719897239 }
97199- case 18446744073709545742LLU: // 99999998iN'''''''''''''''
97240+ case 18446744073709545737LLU: // 99999998iI'''''''''''''''
9720097241 {
9720197242 // ACCUMULATE ARGUMENTS - BEGIN
9720297243 {
@@ -97204,7 +97245,7 @@
9720497245 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9720597246 }
9720697247 // ACCUMULATE ARGUMENTS - END
97207- uint64_t return_to = 18446744073709545739LLU;
97248+ uint64_t return_to = 18446744073709545734LLU;
9720897249 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9720997250 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9721097251 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97213,12 +97254,12 @@
9721397254 state.addr = 839519719621918720LLU; // skipws____
9721497255 break;
9721597256 }
97216- case 18446744073709545739LLU: // 99999998iK'''''''''''''''
97257+ case 18446744073709545734LLU: // 99999998iF'''''''''''''''
9721797258 {
97218- state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
97259+ state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
9721997260 break;
9722097261 }
97221- case 18446744073709545740LLU: // 99999998iL'''''''''''''''
97262+ case 18446744073709545735LLU: // 99999998iG'''''''''''''''
9722297263 {
9722397264 {
9722497265 uint64_t arg = 819828885863530496LLU;
@@ -97230,7 +97271,7 @@
9723097271 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9723197272 }
9723297273 // ACCUMULATE ARGUMENTS - END
97233- uint64_t return_to = 18446744073709545737LLU;
97274+ uint64_t return_to = 18446744073709545732LLU;
9723497275 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9723597276 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9723697277 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97239,19 +97280,19 @@
9723997280 state.addr = 839519719621918720LLU; // skipws____
9724097281 break;
9724197282 }
97242- case 18446744073709545737LLU: // 99999998iI'''''''''''''''
97283+ case 18446744073709545732LLU: // 99999998iD'''''''''''''''
9724397284 {
97244- state.addr = 18446744073709545738LLU; // 99999998iJ'''''''''''''''
97285+ state.addr = 18446744073709545733LLU; // 99999998iE'''''''''''''''
9724597286 break;
9724697287 }
97247- case 18446744073709545738LLU: // 99999998iJ'''''''''''''''
97288+ case 18446744073709545733LLU: // 99999998iE'''''''''''''''
9724897289 {
9724997290 /*id________*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)));
9725097291 /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) != /*id________*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU);
97251- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU) ? 18446744073709545736LLU : 18446744073709545735LLU;
97292+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU) ? 18446744073709545731LLU : 18446744073709545730LLU;
9725297293 break;
9725397294 }
97254- case 18446744073709545736LLU: // 99999998iH'''''''''''''''
97295+ case 18446744073709545731LLU: // 99999998iC'''''''''''''''
9725597296 {
9725697297 // ACCUMULATE ARGUMENTS - BEGIN
9725797298 {
@@ -97259,7 +97300,7 @@
9725997300 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9726097301 }
9726197302 // ACCUMULATE ARGUMENTS - END
97262- uint64_t return_to = 18446744073709545733LLU;
97303+ uint64_t return_to = 18446744073709545728LLU;
9726397304 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9726497305 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9726597306 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97268,12 +97309,12 @@
9726897309 state.addr = 819847183515949359LLU; // reportinit
9726997310 break;
9727097311 }
97271- case 18446744073709545733LLU: // 99999998iE'''''''''''''''
97312+ case 18446744073709545728LLU: // 99999998i_'''''''''''''''
9727297313 {
97273- state.addr = 18446744073709545734LLU; // 99999998iF'''''''''''''''
97314+ state.addr = 18446744073709545729LLU; // 99999998iA'''''''''''''''
9727497315 break;
9727597316 }
97276- case 18446744073709545734LLU: // 99999998iF'''''''''''''''
97317+ case 18446744073709545729LLU: // 99999998iA'''''''''''''''
9727797318 {
9727897319 fprintf(stderr, "%s", "in definition of struct ");
9727997320 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 16LLU, 7LLU));
@@ -97284,10 +97325,10 @@
9728497325 fprintf(stderr, "%s\n", "");
9728597326 exit(-1);
9728697327 }
97287- state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
97328+ state.addr = 18446744073709545730LLU; // 99999998iB'''''''''''''''
9728897329 break;
9728997330 }
97290- case 18446744073709545735LLU: // 99999998iG'''''''''''''''
97331+ case 18446744073709545730LLU: // 99999998iB'''''''''''''''
9729197332 {
9729297333 // ACCUMULATE ARGUMENTS - BEGIN
9729397334 {
@@ -97295,7 +97336,7 @@
9729597336 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9729697337 }
9729797338 // ACCUMULATE ARGUMENTS - END
97298- uint64_t return_to = 18446744073709545731LLU;
97339+ uint64_t return_to = 18446744073709545726LLU;
9729997340 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9730097341 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9730197342 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97304,12 +97345,12 @@
9730497345 state.addr = 839519719621918720LLU; // skipws____
9730597346 break;
9730697347 }
97307- case 18446744073709545731LLU: // 99999998iC'''''''''''''''
97348+ case 18446744073709545726LLU: // 99999998h8'''''''''''''''
9730897349 {
97309- state.addr = 18446744073709545732LLU; // 99999998iD'''''''''''''''
97350+ state.addr = 18446744073709545727LLU; // 99999998h9'''''''''''''''
9731097351 break;
9731197352 }
97312- case 18446744073709545732LLU: // 99999998iD'''''''''''''''
97353+ case 18446744073709545727LLU: // 99999998h9'''''''''''''''
9731397354 {
9731497355 matchid(";", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)));
9731597356 // ACCUMULATE ARGUMENTS - BEGIN
@@ -97322,7 +97363,7 @@
9732297363 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9732397364 }
9732497365 // ACCUMULATE ARGUMENTS - END
97325- uint64_t return_to = 18446744073709545729LLU;
97366+ uint64_t return_to = 18446744073709545724LLU;
9732697367 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
9732797368 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9732897369 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97331,12 +97372,12 @@
9733197372 state.addr = 517555828430075934LLU; // assign_dec
9733297373 break;
9733397374 }
97334- case 18446744073709545729LLU: // 99999998iA'''''''''''''''
97375+ case 18446744073709545724LLU: // 99999998h6'''''''''''''''
9733597376 {
97336- state.addr = 18446744073709545730LLU; // 99999998iB'''''''''''''''
97377+ state.addr = 18446744073709545725LLU; // 99999998h7'''''''''''''''
9733797378 break;
9733897379 }
97339- case 18446744073709545730LLU: // 99999998iB'''''''''''''''
97380+ case 18446744073709545725LLU: // 99999998h7'''''''''''''''
9734097381 {
9734197382 // variable u64 sym_______ goes out of scope
9734297383 // emitted destructur for type u64
@@ -97343,10 +97384,10 @@
9734397384 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 16
9734497385 heap.availilable_size_for_dynamic_objects += 0LLU;
9734597386 heap.availilable_size_for_dynamic_objects += 0LLU;
97346- state.addr = 18446744073709545728LLU; // 99999998i_'''''''''''''''
97387+ state.addr = 18446744073709545723LLU; // 99999998h5'''''''''''''''
9734797388 break;
9734897389 }
97349- case 18446744073709545741LLU: // 99999998iM'''''''''''''''
97390+ case 18446744073709545736LLU: // 99999998iH'''''''''''''''
9735097391 {
9735197392 // ACCUMULATE ARGUMENTS - BEGIN
9735297393 {
@@ -97354,7 +97395,7 @@
9735497395 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9735597396 }
9735697397 // ACCUMULATE ARGUMENTS - END
97357- uint64_t return_to = 18446744073709545726LLU;
97398+ uint64_t return_to = 18446744073709545721LLU;
9735897399 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9735997400 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9736097401 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97363,12 +97404,12 @@
9736397404 state.addr = 819847183515949359LLU; // reportinit
9736497405 break;
9736597406 }
97366- case 18446744073709545726LLU: // 99999998h8'''''''''''''''
97407+ case 18446744073709545721LLU: // 99999998h3'''''''''''''''
9736797408 {
97368- state.addr = 18446744073709545727LLU; // 99999998h9'''''''''''''''
97409+ state.addr = 18446744073709545722LLU; // 99999998h4'''''''''''''''
9736997410 break;
9737097411 }
97371- case 18446744073709545727LLU: // 99999998h9'''''''''''''''
97412+ case 18446744073709545722LLU: // 99999998h4'''''''''''''''
9737297413 {
9737397414 fprintf(stderr, "%s", "in definition of struct ");
9737497415 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 15LLU, 7LLU));
@@ -97377,10 +97418,10 @@
9737797418 fprintf(stderr, "%s\n", "");
9737897419 exit(-1);
9737997420 }
97380- state.addr = 18446744073709545728LLU; // 99999998i_'''''''''''''''
97421+ state.addr = 18446744073709545723LLU; // 99999998h5'''''''''''''''
9738197422 break;
9738297423 }
97383- case 18446744073709545728LLU: // 99999998i_'''''''''''''''
97424+ case 18446744073709545723LLU: // 99999998h5'''''''''''''''
9738497425 {
9738597426 // variable u64 id________ goes out of scope
9738697427 // emitted destructur for type u64
@@ -97388,10 +97429,10 @@
9738897429 // variable u64 sym_______ goes out of scope
9738997430 // emitted destructur for type u64
9739097431 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 14
97391- state.addr = 18446744073709545745LLU; // 99999998iQ'''''''''''''''
97432+ state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
9739297433 break;
9739397434 }
97394- case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
97435+ case 18446744073709545740LLU: // 99999998iL'''''''''''''''
9739597436 {
9739697437 // variable u64 sym_______ goes out of scope
9739797438 // emitted destructur for type u64
@@ -97399,10 +97440,10 @@
9739997440 // variable u64 result____ goes out of scope
9740097441 // emitted destructur for type u64
9740197442 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 12
97402- state.addr = 18446744073709545752LLU; // 99999998iX'''''''''''''''
97443+ state.addr = 18446744073709545747LLU; // 99999998iS'''''''''''''''
9740397444 break;
9740497445 }
97405- case 18446744073709545752LLU: // 99999998iX'''''''''''''''
97446+ case 18446744073709545747LLU: // 99999998iS'''''''''''''''
9740697447 {
9740797448 {
9740897449 uint64_t arg = 0LLU;
@@ -97416,10 +97457,10 @@
9741697457 uint64_t arg = 0;
9741797458 LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9741897459 }
97419- state.addr = 18446744073709545724LLU; // 99999998h6'''''''''''''''
97460+ state.addr = 18446744073709545719LLU; // 99999998h1'''''''''''''''
9742097461 break;
9742197462 }
97422- case 18446744073709545724LLU: // 99999998h6'''''''''''''''
97463+ case 18446744073709545719LLU: // 99999998h1'''''''''''''''
9742397464 {
9742497465 if(!*LOCAL_ACCESS(heap.data, 14LLU, 12LLU))
9742597466 {
@@ -97426,7 +97467,7 @@
9742697467 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14
9742797468 (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
9742897469 {
97429- state.addr = 18446744073709545723LLU; // 99999998h5'''''''''''''''
97470+ state.addr = 18446744073709545718LLU; // 99999998h0'''''''''''''''
9743097471 break;
9743197472 }
9743297473 }
@@ -97454,7 +97495,7 @@
9745497495 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9745597496 }
9745697497 // ACCUMULATE ARGUMENTS - END
97457- uint64_t return_to = 18446744073709545721LLU;
97498+ uint64_t return_to = 18446744073709545716LLU;
9745897499 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9745997500 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9746097501 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97463,12 +97504,12 @@
9746397504 state.addr = 375116000798050091LLU; // TypeOnHeap
9746497505 break;
9746597506 }
97466- case 18446744073709545721LLU: // 99999998h3'''''''''''''''
97507+ case 18446744073709545716LLU: // 99999998hy'''''''''''''''
9746797508 {
97468- state.addr = 18446744073709545722LLU; // 99999998h4'''''''''''''''
97509+ state.addr = 18446744073709545717LLU; // 99999998hz'''''''''''''''
9746997510 break;
9747097511 }
97471- case 18446744073709545722LLU: // 99999998h4'''''''''''''''
97512+ case 18446744073709545717LLU: // 99999998hz'''''''''''''''
9747297513 {
9747397514 /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU) = /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU) + /*reqsize___*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU);
9747497515 ++/*sumheapsz_*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU);
@@ -97477,16 +97518,16 @@
9747797518 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reqsize___ at 15
9747897519 // parameter-reference elemdef___ elemtype__ goes out of scope
9747997520 // parameter list<elemdef___> defpars___ goes out of scope
97480- state.addr = 18446744073709545724LLU; // 99999998h6'''''''''''''''
97521+ state.addr = 18446744073709545719LLU; // 99999998h1'''''''''''''''
9748197522 break;
9748297523 }
97483- case 18446744073709545723LLU: // 99999998h5'''''''''''''''
97524+ case 18446744073709545718LLU: // 99999998h0'''''''''''''''
9748497525 {
9748597526 --/*sumheapsz_*/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU);
97486- state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU) ? 18446744073709545720LLU : 18446744073709545719LLU;
97527+ state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU) ? 18446744073709545715LLU : 18446744073709545714LLU;
9748797528 break;
9748897529 }
97489- case 18446744073709545720LLU: // 99999998h2'''''''''''''''
97530+ case 18446744073709545715LLU: // 99999998hx'''''''''''''''
9749097531 {
9749197532 {
9749297533 uint64_t arg = 0;
@@ -97498,7 +97539,7 @@
9749897539 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9749997540 }
9750097541 // ACCUMULATE ARGUMENTS - END
97501- uint64_t return_to = 18446744073709545717LLU;
97542+ uint64_t return_to = 18446744073709545712LLU;
9750297543 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9750397544 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9750497545 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97507,21 +97548,21 @@
9750797548 state.addr = 567659142103390208LLU; // destrsize_
9750897549 break;
9750997550 }
97510- case 18446744073709545717LLU: // 99999998hz'''''''''''''''
97551+ case 18446744073709545712LLU: // 99999998hu'''''''''''''''
9751197552 {
97512- state.addr = 18446744073709545718LLU; // 99999998h0'''''''''''''''
97553+ state.addr = 18446744073709545713LLU; // 99999998hv'''''''''''''''
9751397554 break;
9751497555 }
97515- case 18446744073709545718LLU: // 99999998h0'''''''''''''''
97556+ case 18446744073709545713LLU: // 99999998hv'''''''''''''''
9751697557 {
9751797558 /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) = /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) + /*reserved__*/*LOCAL_ACCESS(heap.data, 13LLU, 12LLU);
9751897559 // variable u64 reserved__ goes out of scope
9751997560 // emitted destructur for type u64
9752097561 (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reserved__ at 13
97521- state.addr = 18446744073709545719LLU; // 99999998h1'''''''''''''''
97562+ state.addr = 18446744073709545714LLU; // 99999998hw'''''''''''''''
9752297563 break;
9752397564 }
97524- case 18446744073709545719LLU: // 99999998h1'''''''''''''''
97565+ case 18446744073709545714LLU: // 99999998hw'''''''''''''''
9752597566 {
9752697567 // ACCUMULATE ARGUMENTS - BEGIN
9752797568 {
@@ -97545,7 +97586,7 @@
9754597586 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9754697587 }
9754797588 // ACCUMULATE ARGUMENTS - END
97548- uint64_t return_to = 18446744073709545715LLU;
97589+ uint64_t return_to = 18446744073709545710LLU;
9754997590 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
9755097591 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9755197592 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97554,25 +97595,25 @@
9755497595 state.addr = 788334700303681455LLU; // pushstruct
9755597596 break;
9755697597 }
97557- case 18446744073709545715LLU: // 99999998hx'''''''''''''''
97598+ case 18446744073709545710LLU: // 99999998hs'''''''''''''''
9755897599 {
97559- state.addr = 18446744073709545716LLU; // 99999998hy'''''''''''''''
97600+ state.addr = 18446744073709545711LLU; // 99999998ht'''''''''''''''
9756097601 break;
9756197602 }
97562- case 18446744073709545716LLU: // 99999998hy'''''''''''''''
97603+ case 18446744073709545711LLU: // 99999998ht'''''''''''''''
9756397604 {
9756497605 // variable u64 sumheapsz_ goes out of scope
9756597606 // emitted destructur for type u64
9756697607 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sumheapsz_ at 12
97567- state.addr = 18446744073709545725LLU; // 99999998h7'''''''''''''''
97608+ state.addr = 18446744073709545720LLU; // 99999998h2'''''''''''''''
9756897609 break;
9756997610 }
97570- case 18446744073709545725LLU: // 99999998h7'''''''''''''''
97611+ case 18446744073709545720LLU: // 99999998h2'''''''''''''''
9757197612 {
97572- state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU) ? 18446744073709545714LLU : 18446744073709545713LLU;
97613+ state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU) ? 18446744073709545709LLU : 18446744073709545708LLU;
9757397614 break;
9757497615 }
97575- case 18446744073709545714LLU: // 99999998hw'''''''''''''''
97616+ case 18446744073709545709LLU: // 99999998hr'''''''''''''''
9757697617 {
9757797618 {
9757897619 uint64_t arg = 0LLU;
@@ -97588,7 +97629,7 @@
9758897629 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9758997630 }
9759097631 // ACCUMULATE ARGUMENTS - END
97591- uint64_t return_to = 18446744073709545710LLU;
97632+ uint64_t return_to = 18446744073709545705LLU;
9759297633 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9759397634 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9759497635 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97597,12 +97638,12 @@
9759797638 state.addr = 587881345921715008LLU; // emitenter_
9759897639 break;
9759997640 }
97600- case 18446744073709545710LLU: // 99999998hs'''''''''''''''
97641+ case 18446744073709545705LLU: // 99999998hn'''''''''''''''
9760197642 {
97602- state.addr = 18446744073709545711LLU; // 99999998ht'''''''''''''''
97643+ state.addr = 18446744073709545706LLU; // 99999998ho'''''''''''''''
9760397644 break;
9760497645 }
97605- case 18446744073709545711LLU: // 99999998ht'''''''''''''''
97646+ case 18446744073709545706LLU: // 99999998ho'''''''''''''''
9760697647 {
9760797648 {
9760897649 uint64_t arg = 1LLU;
@@ -97625,10 +97666,10 @@
9762597666 uint64_t arg = 0;
9762697667 LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9762797668 }
97628- state.addr = 18446744073709545709LLU; // 99999998hr'''''''''''''''
97669+ state.addr = 18446744073709545704LLU; // 99999998hm'''''''''''''''
9762997670 break;
9763097671 }
97631- case 18446744073709545709LLU: // 99999998hr'''''''''''''''
97672+ case 18446744073709545704LLU: // 99999998hm'''''''''''''''
9763297673 {
9763397674 if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
9763497675 {
@@ -97635,7 +97676,7 @@
9763597676 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
9763697677 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
9763797678 {
97638- state.addr = 18446744073709545708LLU; // 99999998hq'''''''''''''''
97679+ state.addr = 18446744073709545703LLU; // 99999998hl'''''''''''''''
9763997680 break;
9764097681 }
9764197682 }
@@ -97655,7 +97696,7 @@
9765597696 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9765697697 }
9765797698 // ACCUMULATE ARGUMENTS - END
97658- uint64_t return_to = 18446744073709545706LLU;
97699+ uint64_t return_to = 18446744073709545701LLU;
9765997700 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
9766097701 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9766197702 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97664,16 +97705,16 @@
9766497705 state.addr = 731490016794102208LLU; // mkvirtual_
9766597706 break;
9766697707 }
97667- case 18446744073709545706LLU: // 99999998ho'''''''''''''''
97708+ case 18446744073709545701LLU: // 99999998hj'''''''''''''''
9766897709 {
97669- state.addr = 18446744073709545707LLU; // 99999998hp'''''''''''''''
97710+ state.addr = 18446744073709545702LLU; // 99999998hk'''''''''''''''
9767097711 break;
9767197712 }
97672- case 18446744073709545707LLU: // 99999998hp'''''''''''''''
97713+ case 18446744073709545702LLU: // 99999998hk'''''''''''''''
9767397714 {
9767497715 // ACCUMULATE ARGUMENTS - BEGIN
9767597716 // ACCUMULATE ARGUMENTS - END
97676- uint64_t return_to = 18446744073709545704LLU;
97717+ uint64_t return_to = 18446744073709545699LLU;
9767797718 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
9767897719 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9767997720 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97682,12 +97723,12 @@
9768297723 state.addr = 890787671342055424LLU; // varopen___
9768397724 break;
9768497725 }
97685- case 18446744073709545704LLU: // 99999998hm'''''''''''''''
97726+ case 18446744073709545699LLU: // 99999998hh'''''''''''''''
9768697727 {
97687- state.addr = 18446744073709545705LLU; // 99999998hn'''''''''''''''
97728+ state.addr = 18446744073709545700LLU; // 99999998hi'''''''''''''''
9768897729 break;
9768997730 }
97690- case 18446744073709545705LLU: // 99999998hn'''''''''''''''
97731+ case 18446744073709545700LLU: // 99999998hi'''''''''''''''
9769197732 {
9769297733 fprintf(stdout, "%s", "tree_pop_move(&heap, ");
9769397734 // ACCUMULATE ARGUMENTS - BEGIN
@@ -97696,7 +97737,7 @@
9769697737 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9769797738 }
9769897739 // ACCUMULATE ARGUMENTS - END
97699- uint64_t return_to = 18446744073709545702LLU;
97740+ uint64_t return_to = 18446744073709545697LLU;
9770097741 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9770197742 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9770297743 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97705,12 +97746,12 @@
9770597746 state.addr = 787446708198178816LLU; // printnr___
9770697747 break;
9770797748 }
97708- case 18446744073709545702LLU: // 99999998hk'''''''''''''''
97749+ case 18446744073709545697LLU: // 99999998hf'''''''''''''''
9770997750 {
97710- state.addr = 18446744073709545703LLU; // 99999998hl'''''''''''''''
97751+ state.addr = 18446744073709545698LLU; // 99999998hg'''''''''''''''
9771197752 break;
9771297753 }
97713- case 18446744073709545703LLU: // 99999998hl'''''''''''''''
97754+ case 18446744073709545698LLU: // 99999998hg'''''''''''''''
9771497755 {
9771597756 fprintf(stdout, "%s", ", &");
9771697757 // ACCUMULATE ARGUMENTS - BEGIN
@@ -97731,7 +97772,7 @@
9773197772 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9773297773 }
9773397774 // ACCUMULATE ARGUMENTS - END
97734- uint64_t return_to = 18446744073709545700LLU;
97775+ uint64_t return_to = 18446744073709545695LLU;
9773597776 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9773697777 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9773797778 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97740,12 +97781,12 @@
9774097781 state.addr = 587881359725559808LLU; // emitref___
9774197782 break;
9774297783 }
97743- case 18446744073709545700LLU: // 99999998hi'''''''''''''''
97784+ case 18446744073709545695LLU: // 99999998hd'''''''''''''''
9774497785 {
97745- state.addr = 18446744073709545701LLU; // 99999998hj'''''''''''''''
97786+ state.addr = 18446744073709545696LLU; // 99999998he'''''''''''''''
9774697787 break;
9774797788 }
97748- case 18446744073709545701LLU: // 99999998hj'''''''''''''''
97789+ case 18446744073709545696LLU: // 99999998he'''''''''''''''
9774997790 {
9775097791 fprintf(stdout, "%s", ")");
9775197792 // ACCUMULATE ARGUMENTS - BEGIN
@@ -97770,7 +97811,7 @@
9777097811 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9777197812 }
9777297813 // ACCUMULATE ARGUMENTS - END
97773- uint64_t return_to = 18446744073709545698LLU;
97814+ uint64_t return_to = 18446744073709545693LLU;
9777497815 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
9777597816 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9777697817 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97779,12 +97820,12 @@
9777997820 state.addr = 890786842582581248LLU; // varclose__
9778097821 break;
9778197822 }
97782- case 18446744073709545698LLU: // 99999998hg'''''''''''''''
97823+ case 18446744073709545693LLU: // 99999998hb'''''''''''''''
9778397824 {
97784- state.addr = 18446744073709545699LLU; // 99999998hh'''''''''''''''
97825+ state.addr = 18446744073709545694LLU; // 99999998hc'''''''''''''''
9778597826 break;
9778697827 }
97787- case 18446744073709545699LLU: // 99999998hh'''''''''''''''
97828+ case 18446744073709545694LLU: // 99999998hc'''''''''''''''
9778897829 {
9778997830 {
9779097831 uint64_t arg = 0LLU;
@@ -97828,7 +97869,7 @@
9782897869 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9782997870 }
9783097871 // ACCUMULATE ARGUMENTS - END
97831- uint64_t return_to = 18446744073709545696LLU;
97872+ uint64_t return_to = 18446744073709545691LLU;
9783297873 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0));
9783397874 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9783497875 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97837,12 +97878,12 @@
9783797878 state.addr = 587881344696777536LLU; // emitdestr_
9783897879 break;
9783997880 }
97840- case 18446744073709545696LLU: // 99999998he'''''''''''''''
97881+ case 18446744073709545691LLU: // 99999998h$'''''''''''''''
9784197882 {
97842- state.addr = 18446744073709545697LLU; // 99999998hf'''''''''''''''
97883+ state.addr = 18446744073709545692LLU; // 99999998ha'''''''''''''''
9784397884 break;
9784497885 }
97845- case 18446744073709545697LLU: // 99999998hf'''''''''''''''
97886+ case 18446744073709545692LLU: // 99999998ha'''''''''''''''
9784697887 {
9784797888 fprintf(stdout, "%s", "\n // RELEASE temporary destructor-variable");
9784897889 {
@@ -97867,7 +97908,7 @@
9786797908 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9786897909 }
9786997910 // ACCUMULATE ARGUMENTS - END
97870- uint64_t return_to = 18446744073709545693LLU;
97911+ uint64_t return_to = 18446744073709545688LLU;
9787197912 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9787297913 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9787397914 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97876,12 +97917,12 @@
9787697917 state.addr = 587881357748664875LLU; // emitpoptmp
9787797918 break;
9787897919 }
97879- case 18446744073709545693LLU: // 99999998hb'''''''''''''''
97920+ case 18446744073709545688LLU: // 99999998hX'''''''''''''''
9788097921 {
97881- state.addr = 18446744073709545694LLU; // 99999998hc'''''''''''''''
97922+ state.addr = 18446744073709545689LLU; // 99999998hY'''''''''''''''
9788297923 break;
9788397924 }
97884- case 18446744073709545694LLU: // 99999998hc'''''''''''''''
97925+ case 18446744073709545689LLU: // 99999998hY'''''''''''''''
9788597926 {
9788697927 // ACCUMULATE ARGUMENTS - BEGIN
9788797928 {
@@ -97897,7 +97938,7 @@
9789797938 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9789897939 }
9789997940 // ACCUMULATE ARGUMENTS - END
97900- uint64_t return_to = 18446744073709545691LLU;
97941+ uint64_t return_to = 18446744073709545686LLU;
9790197942 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9790297943 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9790397944 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97906,20 +97947,20 @@
9790697947 state.addr = 876449629800090048LLU; // unvirtual_
9790797948 break;
9790897949 }
97909- case 18446744073709545691LLU: // 99999998h$'''''''''''''''
97950+ case 18446744073709545686LLU: // 99999998hV'''''''''''''''
9791097951 {
97911- state.addr = 18446744073709545692LLU; // 99999998ha'''''''''''''''
97952+ state.addr = 18446744073709545687LLU; // 99999998hW'''''''''''''''
9791297953 break;
9791397954 }
97914- case 18446744073709545692LLU: // 99999998ha'''''''''''''''
97955+ case 18446744073709545687LLU: // 99999998hW'''''''''''''''
9791597956 {
9791697957 // variable u64 level_____ goes out of scope
9791797958 // emitted destructur for type u64
9791897959 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 21
97919- state.addr = 18446744073709545695LLU; // 99999998hd'''''''''''''''
97960+ state.addr = 18446744073709545690LLU; // 99999998hZ'''''''''''''''
9792097961 break;
9792197962 }
97922- case 18446744073709545695LLU: // 99999998hd'''''''''''''''
97963+ case 18446744073709545690LLU: // 99999998hZ'''''''''''''''
9792397964 {
9792497965 --/*elemcount_*/*LOCAL_ACCESS(heap.data, 20LLU, 15LLU);
9792597966 // variable u64 INDIRECT__ goes out of scope
@@ -97930,10 +97971,10 @@
9793097971 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference paridx____ at 19
9793197972 // parameter-reference elemdef___ elemtype__ goes out of scope
9793297973 // parameter list<elemdef___> defpars___ goes out of scope
97933- state.addr = 18446744073709545709LLU; // 99999998hr'''''''''''''''
97974+ state.addr = 18446744073709545704LLU; // 99999998hm'''''''''''''''
9793497975 break;
9793597976 }
97936- case 18446744073709545708LLU: // 99999998hq'''''''''''''''
97977+ case 18446744073709545703LLU: // 99999998hl'''''''''''''''
9793797978 {
9793897979 fprintf(stdout, "%s", "\n // RELEASE destructor-argument");
9793997980 {
@@ -97958,7 +97999,7 @@
9795897999 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9795998000 }
9796098001 // ACCUMULATE ARGUMENTS - END
97961- uint64_t return_to = 18446744073709545688LLU;
98002+ uint64_t return_to = 18446744073709545683LLU;
9796298003 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9796398004 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9796498005 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -97967,20 +98008,20 @@
9796798008 state.addr = 587881357748664875LLU; // emitpoptmp
9796898009 break;
9796998010 }
97970- case 18446744073709545688LLU: // 99999998hX'''''''''''''''
98011+ case 18446744073709545683LLU: // 99999998hS'''''''''''''''
9797198012 {
97972- state.addr = 18446744073709545689LLU; // 99999998hY'''''''''''''''
98013+ state.addr = 18446744073709545684LLU; // 99999998hT'''''''''''''''
9797398014 break;
9797498015 }
97975- case 18446744073709545689LLU: // 99999998hY'''''''''''''''
98016+ case 18446744073709545684LLU: // 99999998hT'''''''''''''''
9797698017 {
9797798018 // variable u64 level_____ goes out of scope
9797898019 // emitted destructur for type u64
9797998020 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 17
97980- state.addr = 18446744073709545690LLU; // 99999998hZ'''''''''''''''
98021+ state.addr = 18446744073709545685LLU; // 99999998hU'''''''''''''''
9798198022 break;
9798298023 }
97983- case 18446744073709545690LLU: // 99999998hZ'''''''''''''''
98024+ case 18446744073709545685LLU: // 99999998hU'''''''''''''''
9798498025 {
9798598026 // ACCUMULATE ARGUMENTS - BEGIN
9798698027 {
@@ -97996,7 +98037,7 @@
9799698037 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9799798038 }
9799898039 // ACCUMULATE ARGUMENTS - END
97999- uint64_t return_to = 18446744073709545686LLU;
98040+ uint64_t return_to = 18446744073709545681LLU;
9800098041 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9800198042 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9800298043 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98005,12 +98046,12 @@
9800598046 state.addr = 587881353282000896LLU; // emitleave_
9800698047 break;
9800798048 }
98008- case 18446744073709545686LLU: // 99999998hV'''''''''''''''
98049+ case 18446744073709545681LLU: // 99999998hQ'''''''''''''''
9800998050 {
98010- state.addr = 18446744073709545687LLU; // 99999998hW'''''''''''''''
98051+ state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
9801198052 break;
9801298053 }
98013- case 18446744073709545687LLU: // 99999998hW'''''''''''''''
98054+ case 18446744073709545682LLU: // 99999998hR'''''''''''''''
9801498055 {
9801598056 // variable u64 elemcount_ goes out of scope
9801698057 // emitted destructur for type u64
@@ -98027,15 +98068,15 @@
9802798068 // variable u64 sizelimit_ goes out of scope
9802898069 // emitted destructur for type u64
9802998070 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizelimit_ at 12
98030- state.addr = 18446744073709545712LLU; // 99999998hu'''''''''''''''
98071+ state.addr = 18446744073709545707LLU; // 99999998hp'''''''''''''''
9803198072 break;
9803298073 }
98033- case 18446744073709545712LLU: // 99999998hu'''''''''''''''
98074+ case 18446744073709545707LLU: // 99999998hp'''''''''''''''
9803498075 {
98035- state.addr = 18446744073709545713LLU; // 99999998hv'''''''''''''''
98076+ state.addr = 18446744073709545708LLU; // 99999998hq'''''''''''''''
9803698077 break;
9803798078 }
98038- case 18446744073709545713LLU: // 99999998hv'''''''''''''''
98079+ case 18446744073709545708LLU: // 99999998hq'''''''''''''''
9803998080 {
9804098081 // variable u64 destraddr_ goes out of scope
9804198082 // emitted destructur for type u64
@@ -98042,14 +98083,14 @@
9804298083 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr_ at 11
9804398084 // variable list<elemdef___> defpars___ goes out of scope
9804498085 // emitted destructur for type list<elemdef___>
98045- state.addr = 18446744073709545684LLU; // 99999998hT'''''''''''''''
98086+ state.addr = 18446744073709545679LLU; // 99999998hO'''''''''''''''
9804698087 break;
9804798088 }
98048- case 18446744073709545684LLU: // 99999998hT'''''''''''''''
98089+ case 18446744073709545679LLU: // 99999998hO'''''''''''''''
9804998090 {
9805098091 if(!*LOCAL_ACCESS(heap.data, 10LLU, 9LLU)/*list*/)
9805198092 {
98052- state.addr = 18446744073709545685LLU; // 99999998hU'''''''''''''''
98093+ state.addr = 18446744073709545680LLU; // 99999998hP'''''''''''''''
9805398094 break;
9805498095 }
9805598096 // temporary list-element
@@ -98063,7 +98104,7 @@
9806398104 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9806498105 }
9806598106 // ACCUMULATE ARGUMENTS - END
98066- uint64_t return_to = 18446744073709545683LLU;
98107+ uint64_t return_to = 18446744073709545678LLU;
9806798108 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9806898109 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9806998110 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98072,22 +98113,22 @@
9807298113 state.addr = 18446744073709551437LLU; // 999999997M'''''''''''''''
9807398114 break;
9807498115 }
98075- case 18446744073709545683LLU: // 99999998hS'''''''''''''''
98116+ case 18446744073709545678LLU: // 99999998hN'''''''''''''''
9807698117 {
9807798118 // RELEASE temporary destructor-variable
9807898119 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
98079- state.addr = 18446744073709545684LLU; // 99999998hT'''''''''''''''
98120+ state.addr = 18446744073709545679LLU; // 99999998hO'''''''''''''''
9808098121 break;
9808198122 }
98082- case 18446744073709545685LLU: // 99999998hU'''''''''''''''
98123+ case 18446744073709545680LLU: // 99999998hP'''''''''''''''
9808398124 {
9808498125 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defpars___ at 10
9808598126 heap.availilable_size_for_dynamic_objects += 0LLU;
9808698127 heap.availilable_size_for_dynamic_objects += 0LLU;
98087- state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
98128+ state.addr = 18446744073709545677LLU; // 99999998hM'''''''''''''''
9808898129 break;
9808998130 }
98090- case 18446744073709545762LLU: // 99999998ig'''''''''''''''
98131+ case 18446744073709545757LLU: // 99999998ib'''''''''''''''
9809198132 {
9809298133 {
9809398134 uint64_t arg = 0LLU;
@@ -98096,10 +98137,10 @@
9809698137 *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 876392862416109568LLU;
9809798138
9809898139 /*isunion___*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = /*isunion___*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) == /*def_id____*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
98099- state.addr = /*isunion___*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545681LLU : 18446744073709545680LLU;
98140+ state.addr = /*isunion___*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545676LLU : 18446744073709545675LLU;
9810098141 break;
9810198142 }
98102- case 18446744073709545681LLU: // 99999998hQ'''''''''''''''
98143+ case 18446744073709545676LLU: // 99999998hL'''''''''''''''
9810398144 {
9810498145 {
9810598146 uint64_t arg = 0LLU;
@@ -98111,7 +98152,7 @@
9811198152 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9811298153 }
9811398154 // ACCUMULATE ARGUMENTS - END
98114- uint64_t return_to = 18446744073709545678LLU;
98155+ uint64_t return_to = 18446744073709545673LLU;
9811598156 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9811698157 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9811798158 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98120,12 +98161,12 @@
9812098161 state.addr = 839519719621918720LLU; // skipws____
9812198162 break;
9812298163 }
98123- case 18446744073709545678LLU: // 99999998hN'''''''''''''''
98164+ case 18446744073709545673LLU: // 99999998hI'''''''''''''''
9812498165 {
98125- state.addr = 18446744073709545679LLU; // 99999998hO'''''''''''''''
98166+ state.addr = 18446744073709545674LLU; // 99999998hJ'''''''''''''''
9812698167 break;
9812798168 }
98128- case 18446744073709545679LLU: // 99999998hO'''''''''''''''
98169+ case 18446744073709545674LLU: // 99999998hJ'''''''''''''''
9812998170 {
9813098171 /*union_id__*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 11LLU, 5LLU)));
9813198172 {
@@ -98146,7 +98187,7 @@
9814698187 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9814798188 }
9814898189 // ACCUMULATE ARGUMENTS - END
98149- uint64_t return_to = 18446744073709545675LLU;
98190+ uint64_t return_to = 18446744073709545670LLU;
9815098191 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9815198192 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9815298193 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98155,17 +98196,17 @@
9815598196 state.addr = 590977518136150752LLU; // existstype
9815698197 break;
9815798198 }
98158- case 18446744073709545675LLU: // 99999998hK'''''''''''''''
98199+ case 18446744073709545670LLU: // 99999998hF'''''''''''''''
9815998200 {
98160- state.addr = 18446744073709545676LLU; // 99999998hL'''''''''''''''
98201+ state.addr = 18446744073709545671LLU; // 99999998hG'''''''''''''''
9816198202 break;
9816298203 }
98163- case 18446744073709545676LLU: // 99999998hL'''''''''''''''
98204+ case 18446744073709545671LLU: // 99999998hG'''''''''''''''
9816498205 {
98165- state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709545674LLU : 18446744073709545673LLU;
98206+ state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709545669LLU : 18446744073709545668LLU;
9816698207 break;
9816798208 }
98168- case 18446744073709545674LLU: // 99999998hJ'''''''''''''''
98209+ case 18446744073709545669LLU: // 99999998hE'''''''''''''''
9816998210 {
9817098211 fprintf(stderr, "%s", "re-definition of union ");
9817198212 printid(stderr, /*union_id__*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU));
@@ -98173,18 +98214,18 @@
9817398214 fprintf(stderr, "%s\n", "");
9817498215 exit(-1);
9817598216 }
98176- state.addr = 18446744073709545673LLU; // 99999998hI'''''''''''''''
98217+ state.addr = 18446744073709545668LLU; // 99999998hD'''''''''''''''
9817798218 break;
9817898219 }
98179- case 18446744073709545673LLU: // 99999998hI'''''''''''''''
98220+ case 18446744073709545668LLU: // 99999998hD'''''''''''''''
9818098221 {
9818198222 // variable u64 exists____ goes out of scope
9818298223 // emitted destructur for type u64
9818398224 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference exists____ at 12
98184- state.addr = 18446744073709545677LLU; // 99999998hM'''''''''''''''
98225+ state.addr = 18446744073709545672LLU; // 99999998hH'''''''''''''''
9818598226 break;
9818698227 }
98187- case 18446744073709545677LLU: // 99999998hM'''''''''''''''
98228+ case 18446744073709545672LLU: // 99999998hH'''''''''''''''
9818898229 {
9818998230 {
9819098231 uint64_t arg = 0LLU;
@@ -98196,7 +98237,7 @@
9819698237 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9819798238 }
9819898239 // ACCUMULATE ARGUMENTS - END
98199- uint64_t return_to = 18446744073709545671LLU;
98240+ uint64_t return_to = 18446744073709545666LLU;
9820098241 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9820198242 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9820298243 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98205,12 +98246,12 @@
9820598246 state.addr = 839519719621918720LLU; // skipws____
9820698247 break;
9820798248 }
98208- case 18446744073709545671LLU: // 99999998hG'''''''''''''''
98249+ case 18446744073709545666LLU: // 99999998hB'''''''''''''''
9820998250 {
98210- state.addr = 18446744073709545672LLU; // 99999998hH'''''''''''''''
98251+ state.addr = 18446744073709545667LLU; // 99999998hC'''''''''''''''
9821198252 break;
9821298253 }
98213- case 18446744073709545672LLU: // 99999998hH'''''''''''''''
98254+ case 18446744073709545667LLU: // 99999998hC'''''''''''''''
9821498255 {
9821598256 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 5LLU)));
9821698257 {
@@ -98221,15 +98262,15 @@
9822198262 uint64_t arg = 0LLU;
9822298263 LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9822398264 }
98224- state.addr = 18446744073709545670LLU; // 99999998hF'''''''''''''''
98265+ state.addr = 18446744073709545665LLU; // 99999998hA'''''''''''''''
9822598266 break;
9822698267 }
98227- case 18446744073709545670LLU: // 99999998hF'''''''''''''''
98268+ case 18446744073709545665LLU: // 99999998hA'''''''''''''''
9822898269 {
9822998270 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)) = (uint64_t)getchar();
9823098271 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)) > 255)
9823198272 {
98232- state.addr = 18446744073709545669LLU; // 99999998hE'''''''''''''''
98273+ state.addr = 18446744073709545664LLU; // 99999998h_'''''''''''''''
9823398274 break;
9823498275 }
9823598276 // ACCUMULATE ARGUMENTS - BEGIN
@@ -98238,7 +98279,7 @@
9823898279 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9823998280 }
9824098281 // ACCUMULATE ARGUMENTS - END
98241- uint64_t return_to = 18446744073709545667LLU;
98282+ uint64_t return_to = 18446744073709545662LLU;
9824298283 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9824398284 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9824498285 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98247,12 +98288,12 @@
9824798288 state.addr = 839519719621918720LLU; // skipws____
9824898289 break;
9824998290 }
98250- case 18446744073709545667LLU: // 99999998hC'''''''''''''''
98291+ case 18446744073709545662LLU: // 99999998g8'''''''''''''''
9825198292 {
98252- state.addr = 18446744073709545668LLU; // 99999998hD'''''''''''''''
98293+ state.addr = 18446744073709545663LLU; // 99999998g9'''''''''''''''
9825398294 break;
9825498295 }
98255- case 18446744073709545668LLU: // 99999998hD'''''''''''''''
98296+ case 18446744073709545663LLU: // 99999998g9'''''''''''''''
9825698297 {
9825798298 /*def_id____*/*LOCAL_ACCESS(heap.data, 14LLU, 7LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)));
9825898299 {
@@ -98273,7 +98314,7 @@
9827398314 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9827498315 }
9827598316 // ACCUMULATE ARGUMENTS - END
98276- uint64_t return_to = 18446744073709545664LLU;
98317+ uint64_t return_to = 18446744073709545659LLU;
9827798318 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9827898319 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9827998320 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98282,17 +98323,17 @@
9828298323 state.addr = 590977518136150752LLU; // existstype
9828398324 break;
9828498325 }
98285- case 18446744073709545664LLU: // 99999998h_'''''''''''''''
98326+ case 18446744073709545659LLU: // 99999998g5'''''''''''''''
9828698327 {
98287- state.addr = 18446744073709545665LLU; // 99999998hA'''''''''''''''
98328+ state.addr = 18446744073709545660LLU; // 99999998g6'''''''''''''''
9828898329 break;
9828998330 }
98290- case 18446744073709545665LLU: // 99999998hA'''''''''''''''
98331+ case 18446744073709545660LLU: // 99999998g6'''''''''''''''
9829198332 {
98292- state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) ? 18446744073709545663LLU : 18446744073709545662LLU;
98333+ state.addr = /*exists____*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) ? 18446744073709545658LLU : 18446744073709545657LLU;
9829398334 break;
9829498335 }
98295- case 18446744073709545663LLU: // 99999998g9'''''''''''''''
98336+ case 18446744073709545658LLU: // 99999998g4'''''''''''''''
9829698337 {
9829798338 fprintf(stderr, "%s", "re-definition of union ");
9829898339 printid(stderr, /*union_id__*/*LOCAL_ACCESS(heap.data, 15LLU, 10LLU));
@@ -98302,18 +98343,18 @@
9830298343 fprintf(stderr, "%s\n", "");
9830398344 exit(-1);
9830498345 }
98305- state.addr = 18446744073709545662LLU; // 99999998g8'''''''''''''''
98346+ state.addr = 18446744073709545657LLU; // 99999998g3'''''''''''''''
9830698347 break;
9830798348 }
98308- case 18446744073709545662LLU: // 99999998g8'''''''''''''''
98349+ case 18446744073709545657LLU: // 99999998g3'''''''''''''''
9830998350 {
9831098351 // variable u64 exists____ goes out of scope
9831198352 // emitted destructur for type u64
9831298353 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference exists____ at 15
98313- state.addr = 18446744073709545666LLU; // 99999998hB'''''''''''''''
98354+ state.addr = 18446744073709545661LLU; // 99999998g7'''''''''''''''
9831498355 break;
9831598356 }
98316- case 18446744073709545666LLU: // 99999998hB'''''''''''''''
98357+ case 18446744073709545661LLU: // 99999998g7'''''''''''''''
9831798358 {
9831898359 {
9831998360 uint64_t arg = 0LLU;
@@ -98329,7 +98370,7 @@
9832998370 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9833098371 }
9833198372 // ACCUMULATE ARGUMENTS - END
98332- uint64_t return_to = 18446744073709545659LLU;
98373+ uint64_t return_to = 18446744073709545654LLU;
9833398374 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9833498375 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9833598376 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98338,12 +98379,12 @@
9833898379 state.addr = 839519719621918720LLU; // skipws____
9833998380 break;
9834098381 }
98341- case 18446744073709545659LLU: // 99999998g5'''''''''''''''
98382+ case 18446744073709545654LLU: // 99999998g0'''''''''''''''
9834298383 {
98343- state.addr = 18446744073709545660LLU; // 99999998g6'''''''''''''''
98384+ state.addr = 18446744073709545655LLU; // 99999998g1'''''''''''''''
9834498385 break;
9834598386 }
98346- case 18446744073709545660LLU: // 99999998g6'''''''''''''''
98387+ case 18446744073709545655LLU: // 99999998g1'''''''''''''''
9834798388 {
9834898389 // ACCUMULATE ARGUMENTS - BEGIN
9834998390 {
@@ -98363,7 +98404,7 @@
9836398404 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9836498405 }
9836598406 // ACCUMULATE ARGUMENTS - END
98366- uint64_t return_to = 18446744073709545657LLU;
98407+ uint64_t return_to = 18446744073709545652LLU;
9836798408 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9836898409 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9836998410 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98372,12 +98413,12 @@
9837298413 state.addr = 782701543351519790LLU; // parseelems
9837398414 break;
9837498415 }
98375- case 18446744073709545657LLU: // 99999998g3'''''''''''''''
98416+ case 18446744073709545652LLU: // 99999998gy'''''''''''''''
9837698417 {
98377- state.addr = 18446744073709545658LLU; // 99999998g4'''''''''''''''
98418+ state.addr = 18446744073709545653LLU; // 99999998gz'''''''''''''''
9837898419 break;
9837998420 }
98380- case 18446744073709545658LLU: // 99999998g4'''''''''''''''
98421+ case 18446744073709545653LLU: // 99999998gz'''''''''''''''
9838198422 {
9838298423 {
9838398424 uint64_t arg = /*defpars___*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
@@ -98387,10 +98428,10 @@
9838798428 uint64_t arg = 0;
9838898429 LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9838998430 }
98390- state.addr = 18446744073709545656LLU; // 99999998g2'''''''''''''''
98431+ state.addr = 18446744073709545651LLU; // 99999998gx'''''''''''''''
9839198432 break;
9839298433 }
98393- case 18446744073709545656LLU: // 99999998g2'''''''''''''''
98434+ case 18446744073709545651LLU: // 99999998gx'''''''''''''''
9839498435 {
9839598436 if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
9839698437 {
@@ -98397,7 +98438,7 @@
9839798438 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
9839898439 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
9839998440 {
98400- state.addr = 18446744073709545655LLU; // 99999998g1'''''''''''''''
98441+ state.addr = 18446744073709545650LLU; // 99999998gw'''''''''''''''
9840198442 break;
9840298443 }
9840398444 }
@@ -98425,7 +98466,7 @@
9842598466 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9842698467 }
9842798468 // ACCUMULATE ARGUMENTS - END
98428- uint64_t return_to = 18446744073709545653LLU;
98469+ uint64_t return_to = 18446744073709545648LLU;
9842998470 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9843098471 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9843198472 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98434,12 +98475,12 @@
9843498475 state.addr = 375116000798050091LLU; // TypeOnHeap
9843598476 break;
9843698477 }
98437- case 18446744073709545653LLU: // 99999998gz'''''''''''''''
98478+ case 18446744073709545648LLU: // 99999998gu'''''''''''''''
9843898479 {
98439- state.addr = 18446744073709545654LLU; // 99999998g0'''''''''''''''
98480+ state.addr = 18446744073709545649LLU; // 99999998gv'''''''''''''''
9844098481 break;
9844198482 }
98442- case 18446744073709545654LLU: // 99999998g0'''''''''''''''
98483+ case 18446744073709545649LLU: // 99999998gv'''''''''''''''
9844398484 {
9844498485 /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) = /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) + /*reqsize___*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU);
9844598486 ++/*sumheapsz_*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU);
@@ -98448,10 +98489,10 @@
9844898489 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reqsize___ at 19
9844998490 // parameter-reference elemdef___ elemtype__ goes out of scope
9845098491 // parameter list<elemdef___> defpars___ goes out of scope
98451- state.addr = 18446744073709545656LLU; // 99999998g2'''''''''''''''
98492+ state.addr = 18446744073709545651LLU; // 99999998gx'''''''''''''''
9845298493 break;
9845398494 }
98454- case 18446744073709545655LLU: // 99999998g1'''''''''''''''
98495+ case 18446744073709545650LLU: // 99999998gw'''''''''''''''
9845598496 {
9845698497 /*maxheapsz_*/*LOCAL_ACCESS(heap.data, 16LLU, 13LLU) = max(/*maxheapsz_*/*LOCAL_ACCESS(heap.data, 16LLU, 13LLU), /*sumheapsz_*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU));
9845798498 {
@@ -98468,15 +98509,15 @@
9846898509 tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU));
9846998510 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
9847098511 }
98471- state.addr = 18446744073709545652LLU; // 99999998gy'''''''''''''''
98512+ state.addr = 18446744073709545647LLU; // 99999998gt'''''''''''''''
9847298513 break;
9847398514 }
98474- case 18446744073709545652LLU: // 99999998gy'''''''''''''''
98515+ case 18446744073709545647LLU: // 99999998gt'''''''''''''''
9847598516 {
98476- state.addr = !list_push_move(&heap, &/*constr____*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU), &/*constrs___*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU), 4) ? 18446744073709545651LLU : 18446744073709545650LLU;
98517+ state.addr = !list_push_move(&heap, &/*constr____*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU), &/*constrs___*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU), 4) ? 18446744073709545646LLU : 18446744073709545645LLU;
9847798518 break;
9847898519 }
98479- case 18446744073709545651LLU: // 99999998gx'''''''''''''''
98520+ case 18446744073709545646LLU: // 99999998gs'''''''''''''''
9848098521 {
9848198522 {
9848298523 uint64_t arg = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU);
@@ -98497,7 +98538,7 @@
9849798538 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9849898539 }
9849998540 // ACCUMULATE ARGUMENTS - END
98500- uint64_t return_to = 18446744073709545649LLU;
98541+ uint64_t return_to = 18446744073709545644LLU;
9850198542 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9850298543 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9850398544 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98506,20 +98547,20 @@
9850698547 state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
9850798548 break;
9850898549 }
98509- case 18446744073709545649LLU: // 99999998gv'''''''''''''''
98550+ case 18446744073709545644LLU: // 99999998gq'''''''''''''''
9851098551 {
9851198552 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference constr____ at 19
9851298553 heap.availilable_size_for_dynamic_objects += 0LLU;
9851398554 heap.availilable_size_for_dynamic_objects += 0LLU;
98514- state.addr = 18446744073709545648LLU; // 99999998gu'''''''''''''''
98555+ state.addr = 18446744073709545643LLU; // 99999998gp'''''''''''''''
9851598556 break;
9851698557 }
98517- case 18446744073709545650LLU: // 99999998gw'''''''''''''''
98558+ case 18446744073709545645LLU: // 99999998gr'''''''''''''''
9851898559 {
98519- state.addr = 18446744073709545648LLU; // 99999998gu'''''''''''''''
98560+ state.addr = 18446744073709545643LLU; // 99999998gp'''''''''''''''
9852098561 break;
9852198562 }
98522- case 18446744073709545648LLU: // 99999998gu'''''''''''''''
98563+ case 18446744073709545643LLU: // 99999998gp'''''''''''''''
9852398564 {
9852498565 // variable variant___ constr____ goes out of scope
9852598566 // (uninitialized -> no destructor-call)
@@ -98533,10 +98574,10 @@
9853398574 // variable u64 sumheapsz_ goes out of scope
9853498575 // emitted destructur for type u64
9853598576 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sumheapsz_ at 15
98536- state.addr = 18446744073709545661LLU; // 99999998g7'''''''''''''''
98577+ state.addr = 18446744073709545656LLU; // 99999998g2'''''''''''''''
9853798578 break;
9853898579 }
98539- case 18446744073709545661LLU: // 99999998g7'''''''''''''''
98580+ case 18446744073709545656LLU: // 99999998g2'''''''''''''''
9854098581 {
9854198582 {
9854298583 uint64_t arg = 0LLU;
@@ -98552,7 +98593,7 @@
9855298593 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9855398594 }
9855498595 // ACCUMULATE ARGUMENTS - END
98555- uint64_t return_to = 18446744073709545646LLU;
98596+ uint64_t return_to = 18446744073709545641LLU;
9855698597 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9855798598 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9855898599 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98561,18 +98602,18 @@
9856198602 state.addr = 839519719621918720LLU; // skipws____
9856298603 break;
9856398604 }
98564- case 18446744073709545646LLU: // 99999998gs'''''''''''''''
98605+ case 18446744073709545641LLU: // 99999998gn'''''''''''''''
9856598606 {
98566- state.addr = 18446744073709545647LLU; // 99999998gt'''''''''''''''
98607+ state.addr = 18446744073709545642LLU; // 99999998go'''''''''''''''
9856798608 break;
9856898609 }
98569- case 18446744073709545647LLU: // 99999998gt'''''''''''''''
98610+ case 18446744073709545642LLU: // 99999998go'''''''''''''''
9857098611 {
9857198612 /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU));
98572- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU) ? 18446744073709545645LLU : 18446744073709545644LLU;
98613+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU) ? 18446744073709545640LLU : 18446744073709545639LLU;
9857398614 break;
9857498615 }
98575- case 18446744073709545645LLU: // 99999998gr'''''''''''''''
98616+ case 18446744073709545640LLU: // 99999998gm'''''''''''''''
9857698617 {
9857798618 *LOCAL_ACCESS(heap.data, 16LLU, 12LLU) = 0LLU;
9857898619
@@ -98579,10 +98620,10 @@
9857998620 ungetc(0, stdin);
9858098621 heap.availilable_size_for_dynamic_objects += 0LLU;
9858198622 heap.availilable_size_for_dynamic_objects += 0LLU;
98582- state.addr = 18446744073709545643LLU; // 99999998gp'''''''''''''''
98623+ state.addr = 18446744073709545638LLU; // 99999998gk'''''''''''''''
9858398624 break;
9858498625 }
98585- case 18446744073709545644LLU: // 99999998gq'''''''''''''''
98626+ case 18446744073709545639LLU: // 99999998gl'''''''''''''''
9858698627 {
9858798628 {
9858898629 uint64_t arg = 124LLU;
@@ -98589,10 +98630,10 @@
9858998630 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9859098631 }
9859198632 /*result____*/*LOCAL_ACCESS(heap.data, 17LLU, 14LLU) = /*separator_*/*LOCAL_ACCESS(heap.data, 17LLU, 16LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU));
98592- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 17LLU, 14LLU) ? 18446744073709545642LLU : 18446744073709545641LLU;
98633+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 17LLU, 14LLU) ? 18446744073709545637LLU : 18446744073709545636LLU;
9859398634 break;
9859498635 }
98595- case 18446744073709545642LLU: // 99999998go'''''''''''''''
98636+ case 18446744073709545637LLU: // 99999998gj'''''''''''''''
9859698637 {
9859798638 {
9859898639 uint64_t arg = 548504326530550772LLU;
@@ -98608,7 +98649,7 @@
9860898649 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9860998650 }
9861098651 // ACCUMULATE ARGUMENTS - END
98611- uint64_t return_to = 18446744073709545639LLU;
98652+ uint64_t return_to = 18446744073709545634LLU;
9861298653 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9861398654 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9861498655 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98617,19 +98658,19 @@
9861798658 state.addr = 839519719621918720LLU; // skipws____
9861898659 break;
9861998660 }
98620- case 18446744073709545639LLU: // 99999998gl'''''''''''''''
98661+ case 18446744073709545634LLU: // 99999998gg'''''''''''''''
9862198662 {
98622- state.addr = 18446744073709545640LLU; // 99999998gm'''''''''''''''
98663+ state.addr = 18446744073709545635LLU; // 99999998gh'''''''''''''''
9862398664 break;
9862498665 }
98625- case 18446744073709545640LLU: // 99999998gm'''''''''''''''
98666+ case 18446744073709545635LLU: // 99999998gh'''''''''''''''
9862698667 {
9862798668 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 5LLU)));
9862898669 /*result____*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) == /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU);
98629- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) ? 18446744073709545638LLU : 18446744073709545637LLU;
98670+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) ? 18446744073709545633LLU : 18446744073709545632LLU;
9863098671 break;
9863198672 }
98632- case 18446744073709545638LLU: // 99999998gk'''''''''''''''
98673+ case 18446744073709545633LLU: // 99999998gf'''''''''''''''
9863398674 {
9863498675 // ACCUMULATE ARGUMENTS - BEGIN
9863598676 {
@@ -98637,7 +98678,7 @@
9863798678 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9863898679 }
9863998680 // ACCUMULATE ARGUMENTS - END
98640- uint64_t return_to = 18446744073709545635LLU;
98681+ uint64_t return_to = 18446744073709545630LLU;
9864198682 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9864298683 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9864398684 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98646,12 +98687,12 @@
9864698687 state.addr = 839519719621918720LLU; // skipws____
9864798688 break;
9864898689 }
98649- case 18446744073709545635LLU: // 99999998gh'''''''''''''''
98690+ case 18446744073709545630LLU: // 99999998gc'''''''''''''''
9865098691 {
98651- state.addr = 18446744073709545636LLU; // 99999998gi'''''''''''''''
98692+ state.addr = 18446744073709545631LLU; // 99999998gd'''''''''''''''
9865298693 break;
9865398694 }
98654- case 18446744073709545636LLU: // 99999998gi'''''''''''''''
98695+ case 18446744073709545631LLU: // 99999998gd'''''''''''''''
9865598696 {
9865698697 {
9865798698 uint64_t arg = 819828885863530496LLU;
@@ -98663,7 +98704,7 @@
9866398704 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9866498705 }
9866598706 // ACCUMULATE ARGUMENTS - END
98666- uint64_t return_to = 18446744073709545633LLU;
98707+ uint64_t return_to = 18446744073709545628LLU;
9866798708 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9866898709 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9866998710 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98672,19 +98713,19 @@
9867298713 state.addr = 839519719621918720LLU; // skipws____
9867398714 break;
9867498715 }
98675- case 18446744073709545633LLU: // 99999998gf'''''''''''''''
98716+ case 18446744073709545628LLU: // 99999998ga'''''''''''''''
9867698717 {
98677- state.addr = 18446744073709545634LLU; // 99999998gg'''''''''''''''
98718+ state.addr = 18446744073709545629LLU; // 99999998gb'''''''''''''''
9867898719 break;
9867998720 }
98680- case 18446744073709545634LLU: // 99999998gg'''''''''''''''
98721+ case 18446744073709545629LLU: // 99999998gb'''''''''''''''
9868198722 {
9868298723 /*id________*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 5LLU)));
9868398724 /*result____*/*LOCAL_ACCESS(heap.data, 20LLU, 14LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) != /*id________*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU);
98684- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 20LLU, 14LLU) ? 18446744073709545632LLU : 18446744073709545631LLU;
98725+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 20LLU, 14LLU) ? 18446744073709545627LLU : 18446744073709545626LLU;
9868598726 break;
9868698727 }
98687- case 18446744073709545632LLU: // 99999998ge'''''''''''''''
98728+ case 18446744073709545627LLU: // 99999998g$'''''''''''''''
9868898729 {
9868998730 // ACCUMULATE ARGUMENTS - BEGIN
9869098731 {
@@ -98692,7 +98733,7 @@
9869298733 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9869398734 }
9869498735 // ACCUMULATE ARGUMENTS - END
98695- uint64_t return_to = 18446744073709545629LLU;
98736+ uint64_t return_to = 18446744073709545624LLU;
9869698737 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9869798738 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9869898739 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98701,12 +98742,12 @@
9870198742 state.addr = 819847183515949359LLU; // reportinit
9870298743 break;
9870398744 }
98704- case 18446744073709545629LLU: // 99999998gb'''''''''''''''
98745+ case 18446744073709545624LLU: // 99999998gX'''''''''''''''
9870598746 {
98706- state.addr = 18446744073709545630LLU; // 99999998gc'''''''''''''''
98747+ state.addr = 18446744073709545625LLU; // 99999998gY'''''''''''''''
9870798748 break;
9870898749 }
98709- case 18446744073709545630LLU: // 99999998gc'''''''''''''''
98750+ case 18446744073709545625LLU: // 99999998gY'''''''''''''''
9871098751 {
9871198752 fprintf(stderr, "%s", "in definition of union ");
9871298753 printid(stderr, /*union_id__*/*LOCAL_ACCESS(heap.data, 20LLU, 10LLU));
@@ -98717,10 +98758,10 @@
9871798758 fprintf(stderr, "%s\n", "");
9871898759 exit(-1);
9871998760 }
98720- state.addr = 18446744073709545631LLU; // 99999998gd'''''''''''''''
98761+ state.addr = 18446744073709545626LLU; // 99999998gZ'''''''''''''''
9872198762 break;
9872298763 }
98723- case 18446744073709545631LLU: // 99999998gd'''''''''''''''
98764+ case 18446744073709545626LLU: // 99999998gZ'''''''''''''''
9872498765 {
9872598766 // ACCUMULATE ARGUMENTS - BEGIN
9872698767 {
@@ -98728,7 +98769,7 @@
9872898769 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9872998770 }
9873098771 // ACCUMULATE ARGUMENTS - END
98731- uint64_t return_to = 18446744073709545627LLU;
98772+ uint64_t return_to = 18446744073709545622LLU;
9873298773 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9873398774 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9873498775 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98737,12 +98778,12 @@
9873798778 state.addr = 839519719621918720LLU; // skipws____
9873898779 break;
9873998780 }
98740- case 18446744073709545627LLU: // 99999998g$'''''''''''''''
98781+ case 18446744073709545622LLU: // 99999998gV'''''''''''''''
9874198782 {
98742- state.addr = 18446744073709545628LLU; // 99999998ga'''''''''''''''
98783+ state.addr = 18446744073709545623LLU; // 99999998gW'''''''''''''''
9874398784 break;
9874498785 }
98745- case 18446744073709545628LLU: // 99999998ga'''''''''''''''
98786+ case 18446744073709545623LLU: // 99999998gW'''''''''''''''
9874698787 {
9874798788 matchid(";", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 5LLU)));
9874898789 // ACCUMULATE ARGUMENTS - BEGIN
@@ -98755,7 +98796,7 @@
9875598796 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9875698797 }
9875798798 // ACCUMULATE ARGUMENTS - END
98758- uint64_t return_to = 18446744073709545625LLU;
98799+ uint64_t return_to = 18446744073709545620LLU;
9875998800 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
9876098801 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9876198802 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98764,12 +98805,12 @@
9876498805 state.addr = 517555828430075934LLU; // assign_dec
9876598806 break;
9876698807 }
98767- case 18446744073709545625LLU: // 99999998gY'''''''''''''''
98808+ case 18446744073709545620LLU: // 99999998gT'''''''''''''''
9876898809 {
98769- state.addr = 18446744073709545626LLU; // 99999998gZ'''''''''''''''
98810+ state.addr = 18446744073709545621LLU; // 99999998gU'''''''''''''''
9877098811 break;
9877198812 }
98772- case 18446744073709545626LLU: // 99999998gZ'''''''''''''''
98813+ case 18446744073709545621LLU: // 99999998gU'''''''''''''''
9877398814 {
9877498815 ungetc(0, stdin);
9877598816 // variable u64 sym_______ goes out of scope
@@ -98777,10 +98818,10 @@
9877798818 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 20
9877898819 heap.availilable_size_for_dynamic_objects += 0LLU;
9877998820 heap.availilable_size_for_dynamic_objects += 0LLU;
98780- state.addr = 18446744073709545624LLU; // 99999998gX'''''''''''''''
98821+ state.addr = 18446744073709545619LLU; // 99999998gS'''''''''''''''
9878198822 break;
9878298823 }
98783- case 18446744073709545637LLU: // 99999998gj'''''''''''''''
98824+ case 18446744073709545632LLU: // 99999998ge'''''''''''''''
9878498825 {
9878598826 // ACCUMULATE ARGUMENTS - BEGIN
9878698827 {
@@ -98788,7 +98829,7 @@
9878898829 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9878998830 }
9879098831 // ACCUMULATE ARGUMENTS - END
98791- uint64_t return_to = 18446744073709545622LLU;
98832+ uint64_t return_to = 18446744073709545617LLU;
9879298833 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9879398834 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9879498835 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98797,12 +98838,12 @@
9879798838 state.addr = 819847183515949359LLU; // reportinit
9879898839 break;
9879998840 }
98800- case 18446744073709545622LLU: // 99999998gV'''''''''''''''
98841+ case 18446744073709545617LLU: // 99999998gQ'''''''''''''''
9880198842 {
98802- state.addr = 18446744073709545623LLU; // 99999998gW'''''''''''''''
98843+ state.addr = 18446744073709545618LLU; // 99999998gR'''''''''''''''
9880398844 break;
9880498845 }
98805- case 18446744073709545623LLU: // 99999998gW'''''''''''''''
98846+ case 18446744073709545618LLU: // 99999998gR'''''''''''''''
9880698847 {
9880798848 fprintf(stderr, "%s", "in definition of union ");
9880898849 printid(stderr, /*union_id__*/*LOCAL_ACCESS(heap.data, 19LLU, 10LLU));
@@ -98811,10 +98852,10 @@
9881198852 fprintf(stderr, "%s\n", "");
9881298853 exit(-1);
9881398854 }
98814- state.addr = 18446744073709545624LLU; // 99999998gX'''''''''''''''
98855+ state.addr = 18446744073709545619LLU; // 99999998gS'''''''''''''''
9881598856 break;
9881698857 }
98817- case 18446744073709545624LLU: // 99999998gX'''''''''''''''
98858+ case 18446744073709545619LLU: // 99999998gS'''''''''''''''
9881898859 {
9881998860 // variable u64 id________ goes out of scope
9882098861 // emitted destructur for type u64
@@ -98822,18 +98863,18 @@
9882298863 // variable u64 sym_______ goes out of scope
9882398864 // emitted destructur for type u64
9882498865 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 18
98825- state.addr = 18446744073709545641LLU; // 99999998gn'''''''''''''''
98866+ state.addr = 18446744073709545636LLU; // 99999998gi'''''''''''''''
9882698867 break;
9882798868 }
98828- case 18446744073709545641LLU: // 99999998gn'''''''''''''''
98869+ case 18446744073709545636LLU: // 99999998gi'''''''''''''''
9882998870 {
9883098871 // variable u64 separator_ goes out of scope
9883198872 // emitted destructur for type u64
9883298873 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference separator_ at 17
98833- state.addr = 18446744073709545643LLU; // 99999998gp'''''''''''''''
98874+ state.addr = 18446744073709545638LLU; // 99999998gk'''''''''''''''
9883498875 break;
9883598876 }
98836- case 18446744073709545643LLU: // 99999998gp'''''''''''''''
98877+ case 18446744073709545638LLU: // 99999998gk'''''''''''''''
9883798878 {
9883898879 // variable u64 terminator goes out of scope
9883998880 // emitted destructur for type u64
@@ -98841,15 +98882,15 @@
9884198882 // variable u64 result____ goes out of scope
9884298883 // emitted destructur for type u64
9884398884 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 15
98844- state.addr = 18446744073709545670LLU; // 99999998hF'''''''''''''''
98885+ state.addr = 18446744073709545665LLU; // 99999998hA'''''''''''''''
9884598886 break;
9884698887 }
98847- case 18446744073709545669LLU: // 99999998hE'''''''''''''''
98888+ case 18446744073709545664LLU: // 99999998h_'''''''''''''''
9884898889 {
98849- state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU) ? 18446744073709545620LLU : 18446744073709545619LLU;
98890+ state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU) ? 18446744073709545615LLU : 18446744073709545614LLU;
9885098891 break;
9885198892 }
98852- case 18446744073709545620LLU: // 99999998gT'''''''''''''''
98893+ case 18446744073709545615LLU: // 99999998gO'''''''''''''''
9885398894 {
9885498895 {
9885598896 uint64_t arg = 0;
@@ -98861,7 +98902,7 @@
9886198902 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9886298903 }
9886398904 // ACCUMULATE ARGUMENTS - END
98864- uint64_t return_to = 18446744073709545617LLU;
98905+ uint64_t return_to = 18446744073709545612LLU;
9886598906 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9886698907 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9886798908 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98870,21 +98911,21 @@
9887098911 state.addr = 567659142103390208LLU; // destrsize_
9887198912 break;
9887298913 }
98873- case 18446744073709545617LLU: // 99999998gQ'''''''''''''''
98914+ case 18446744073709545612LLU: // 99999998gL'''''''''''''''
9887498915 {
98875- state.addr = 18446744073709545618LLU; // 99999998gR'''''''''''''''
98916+ state.addr = 18446744073709545613LLU; // 99999998gM'''''''''''''''
9887698917 break;
9887798918 }
98878- case 18446744073709545618LLU: // 99999998gR'''''''''''''''
98919+ case 18446744073709545613LLU: // 99999998gM'''''''''''''''
9887998920 {
9888098921 /*maxheapsz_*/*LOCAL_ACCESS(heap.data, 15LLU, 13LLU) = /*maxheapsz_*/*LOCAL_ACCESS(heap.data, 15LLU, 13LLU) + /*reserved__*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU);
9888198922 // variable u64 reserved__ goes out of scope
9888298923 // emitted destructur for type u64
9888398924 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reserved__ at 15
98884- state.addr = 18446744073709545619LLU; // 99999998gS'''''''''''''''
98925+ state.addr = 18446744073709545614LLU; // 99999998gN'''''''''''''''
9888598926 break;
9888698927 }
98887- case 18446744073709545619LLU: // 99999998gS'''''''''''''''
98928+ case 18446744073709545614LLU: // 99999998gN'''''''''''''''
9888898929 {
9888998930 // ACCUMULATE ARGUMENTS - BEGIN
9889098931 {
@@ -98908,7 +98949,7 @@
9890898949 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9890998950 }
9891098951 // ACCUMULATE ARGUMENTS - END
98911- uint64_t return_to = 18446744073709545615LLU;
98952+ uint64_t return_to = 18446744073709545610LLU;
9891298953 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
9891398954 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9891498955 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -98917,22 +98958,22 @@
9891798958 state.addr = 788334702348118592LLU; // pushunion_
9891898959 break;
9891998960 }
98920- case 18446744073709545615LLU: // 99999998gO'''''''''''''''
98961+ case 18446744073709545610LLU: // 99999998gJ'''''''''''''''
9892198962 {
98922- state.addr = 18446744073709545616LLU; // 99999998gP'''''''''''''''
98963+ state.addr = 18446744073709545611LLU; // 99999998gK'''''''''''''''
9892398964 break;
9892498965 }
98925- case 18446744073709545616LLU: // 99999998gP'''''''''''''''
98966+ case 18446744073709545611LLU: // 99999998gK'''''''''''''''
9892698967 {
98927- state.addr = 18446744073709545621LLU; // 99999998gU'''''''''''''''
98968+ state.addr = 18446744073709545616LLU; // 99999998gP'''''''''''''''
9892898969 break;
9892998970 }
98930- case 18446744073709545621LLU: // 99999998gU'''''''''''''''
98971+ case 18446744073709545616LLU: // 99999998gP'''''''''''''''
9893198972 {
98932- state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU) ? 18446744073709545614LLU : 18446744073709545613LLU;
98973+ state.addr = /*destraddr_*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU) ? 18446744073709545609LLU : 18446744073709545608LLU;
9893398974 break;
9893498975 }
98935- case 18446744073709545614LLU: // 99999998gN'''''''''''''''
98976+ case 18446744073709545609LLU: // 99999998gI'''''''''''''''
9893698977 {
9893798978 {
9893898979 uint64_t arg = /*tmpaddr___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 0LLU));
@@ -98946,10 +98987,10 @@
9894698987 uint64_t arg = 0;
9894798988 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9894898989 }
98949- state.addr = 18446744073709545612LLU; // 99999998gL'''''''''''''''
98990+ state.addr = 18446744073709545607LLU; // 99999998gG'''''''''''''''
9895098991 break;
9895198992 }
98952- case 18446744073709545612LLU: // 99999998gL'''''''''''''''
98993+ case 18446744073709545607LLU: // 99999998gG'''''''''''''''
9895398994 {
9895498995 if(!*LOCAL_ACCESS(heap.data, 17LLU, 15LLU))
9895598996 {
@@ -98956,7 +98997,7 @@
9895698997 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
9895798998 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 16
9895898999 {
98959- state.addr = 18446744073709545611LLU; // 99999998gK'''''''''''''''
99000+ state.addr = 18446744073709545606LLU; // 99999998gF'''''''''''''''
9896099001 break;
9896199002 }
9896299003 }
@@ -98965,10 +99006,10 @@
9896599006 --/*tmpaddr___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
9896699007 // parameter-reference variant___ constr____ goes out of scope
9896799008 // parameter list<variant___> constrs___ goes out of scope
98968- state.addr = 18446744073709545612LLU; // 99999998gL'''''''''''''''
99009+ state.addr = 18446744073709545607LLU; // 99999998gG'''''''''''''''
9896999010 break;
9897099011 }
98971- case 18446744073709545611LLU: // 99999998gK'''''''''''''''
99012+ case 18446744073709545606LLU: // 99999998gF'''''''''''''''
9897299013 {
9897399014 {
9897499015 uint64_t arg = /*constrs___*/*LOCAL_ACCESS(heap.data, 15LLU, 11LLU);
@@ -98978,10 +99019,10 @@
9897899019 uint64_t arg = 0;
9897999020 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9898099021 }
98981- state.addr = 18446744073709545610LLU; // 99999998gJ'''''''''''''''
99022+ state.addr = 18446744073709545605LLU; // 99999998gE'''''''''''''''
9898299023 break;
9898399024 }
98984- case 18446744073709545610LLU: // 99999998gJ'''''''''''''''
99025+ case 18446744073709545605LLU: // 99999998gE'''''''''''''''
9898599026 {
9898699027 if(!*LOCAL_ACCESS(heap.data, 17LLU, 15LLU))
9898799028 {
@@ -98988,7 +99029,7 @@
9898899029 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
9898999030 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 16
9899099031 {
98991- state.addr = 18446744073709545609LLU; // 99999998gI'''''''''''''''
99032+ state.addr = 18446744073709545604LLU; // 99999998gD'''''''''''''''
9899299033 break;
9899399034 }
9899499035 }
@@ -99009,7 +99050,7 @@
9900999050 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9901099051 }
9901199052 // ACCUMULATE ARGUMENTS - END
99012- uint64_t return_to = 18446744073709545607LLU;
99053+ uint64_t return_to = 18446744073709545602LLU;
9901399054 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9901499055 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9901599056 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99018,12 +99059,12 @@
9901899059 state.addr = 587881345921715008LLU; // emitenter_
9901999060 break;
9902099061 }
99021- case 18446744073709545607LLU: // 99999998gG'''''''''''''''
99062+ case 18446744073709545602LLU: // 99999998gB'''''''''''''''
9902299063 {
99023- state.addr = 18446744073709545608LLU; // 99999998gH'''''''''''''''
99064+ state.addr = 18446744073709545603LLU; // 99999998gC'''''''''''''''
9902499065 break;
9902599066 }
99026- case 18446744073709545608LLU: // 99999998gH'''''''''''''''
99067+ case 18446744073709545603LLU: // 99999998gC'''''''''''''''
9902799068 {
9902899069 fprintf(stdout, "%s", "\n // destructor for variant ");
9902999070 printid(stdout, /*constr____*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 19LLU, 16LLU), 0LLU)));
@@ -99044,10 +99085,10 @@
9904499085 uint64_t arg = 0;
9904599086 LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9904699087 }
99047- state.addr = 18446744073709545606LLU; // 99999998gF'''''''''''''''
99088+ state.addr = 18446744073709545601LLU; // 99999998gA'''''''''''''''
9904899089 break;
9904999090 }
99050- case 18446744073709545606LLU: // 99999998gF'''''''''''''''
99091+ case 18446744073709545601LLU: // 99999998gA'''''''''''''''
9905199092 {
9905299093 if(!*LOCAL_ACCESS(heap.data, 23LLU, 21LLU))
9905399094 {
@@ -99054,7 +99095,7 @@
9905499095 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
9905599096 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22
9905699097 {
99057- state.addr = 18446744073709545605LLU; // 99999998gE'''''''''''''''
99098+ state.addr = 18446744073709545600LLU; // 99999998g_'''''''''''''''
9905899099 break;
9905999100 }
9906099101 }
@@ -99078,7 +99119,7 @@
9907899119 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9907999120 }
9908099121 // ACCUMULATE ARGUMENTS - END
99081- uint64_t return_to = 18446744073709545603LLU;
99122+ uint64_t return_to = 18446744073709545598LLU;
9908299123 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
9908399124 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9908499125 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99087,16 +99128,16 @@
9908799128 state.addr = 731490016794102208LLU; // mkvirtual_
9908899129 break;
9908999130 }
99090- case 18446744073709545603LLU: // 99999998gC'''''''''''''''
99131+ case 18446744073709545598LLU: // 99999998f8'''''''''''''''
9909199132 {
99092- state.addr = 18446744073709545604LLU; // 99999998gD'''''''''''''''
99133+ state.addr = 18446744073709545599LLU; // 99999998f9'''''''''''''''
9909399134 break;
9909499135 }
99095- case 18446744073709545604LLU: // 99999998gD'''''''''''''''
99136+ case 18446744073709545599LLU: // 99999998f9'''''''''''''''
9909699137 {
9909799138 // ACCUMULATE ARGUMENTS - BEGIN
9909899139 // ACCUMULATE ARGUMENTS - END
99099- uint64_t return_to = 18446744073709545601LLU;
99140+ uint64_t return_to = 18446744073709545596LLU;
9910099141 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
9910199142 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9910299143 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99105,12 +99146,12 @@
9910599146 state.addr = 890787671342055424LLU; // varopen___
9910699147 break;
9910799148 }
99108- case 18446744073709545601LLU: // 99999998gA'''''''''''''''
99149+ case 18446744073709545596LLU: // 99999998f6'''''''''''''''
9910999150 {
99110- state.addr = 18446744073709545602LLU; // 99999998gB'''''''''''''''
99151+ state.addr = 18446744073709545597LLU; // 99999998f7'''''''''''''''
9911199152 break;
9911299153 }
99113- case 18446744073709545602LLU: // 99999998gB'''''''''''''''
99154+ case 18446744073709545597LLU: // 99999998f7'''''''''''''''
9911499155 {
9911599156 fprintf(stdout, "%s", "tree_pop_move(&heap, ");
9911699157 // ACCUMULATE ARGUMENTS - BEGIN
@@ -99119,7 +99160,7 @@
9911999160 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9912099161 }
9912199162 // ACCUMULATE ARGUMENTS - END
99122- uint64_t return_to = 18446744073709545599LLU;
99163+ uint64_t return_to = 18446744073709545594LLU;
9912399164 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9912499165 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9912599166 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99128,12 +99169,12 @@
9912899169 state.addr = 787446708198178816LLU; // printnr___
9912999170 break;
9913099171 }
99131- case 18446744073709545599LLU: // 99999998f9'''''''''''''''
99172+ case 18446744073709545594LLU: // 99999998f4'''''''''''''''
9913299173 {
99133- state.addr = 18446744073709545600LLU; // 99999998g_'''''''''''''''
99174+ state.addr = 18446744073709545595LLU; // 99999998f5'''''''''''''''
9913499175 break;
9913599176 }
99136- case 18446744073709545600LLU: // 99999998g_'''''''''''''''
99177+ case 18446744073709545595LLU: // 99999998f5'''''''''''''''
9913799178 {
9913899179 fprintf(stdout, "%s", ", &");
9913999180 // ACCUMULATE ARGUMENTS - BEGIN
@@ -99154,7 +99195,7 @@
9915499195 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9915599196 }
9915699197 // ACCUMULATE ARGUMENTS - END
99157- uint64_t return_to = 18446744073709545597LLU;
99198+ uint64_t return_to = 18446744073709545592LLU;
9915899199 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9915999200 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9916099201 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99163,12 +99204,12 @@
9916399204 state.addr = 587881359725559808LLU; // emitref___
9916499205 break;
9916599206 }
99166- case 18446744073709545597LLU: // 99999998f7'''''''''''''''
99207+ case 18446744073709545592LLU: // 99999998f2'''''''''''''''
9916799208 {
99168- state.addr = 18446744073709545598LLU; // 99999998f8'''''''''''''''
99209+ state.addr = 18446744073709545593LLU; // 99999998f3'''''''''''''''
9916999210 break;
9917099211 }
99171- case 18446744073709545598LLU: // 99999998f8'''''''''''''''
99212+ case 18446744073709545593LLU: // 99999998f3'''''''''''''''
9917299213 {
9917399214 fprintf(stdout, "%s", ")");
9917499215 // ACCUMULATE ARGUMENTS - BEGIN
@@ -99193,7 +99234,7 @@
9919399234 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9919499235 }
9919599236 // ACCUMULATE ARGUMENTS - END
99196- uint64_t return_to = 18446744073709545595LLU;
99237+ uint64_t return_to = 18446744073709545590LLU;
9919799238 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
9919899239 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9919999240 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99202,12 +99243,12 @@
9920299243 state.addr = 890786842582581248LLU; // varclose__
9920399244 break;
9920499245 }
99205- case 18446744073709545595LLU: // 99999998f5'''''''''''''''
99246+ case 18446744073709545590LLU: // 99999998f0'''''''''''''''
9920699247 {
99207- state.addr = 18446744073709545596LLU; // 99999998f6'''''''''''''''
99248+ state.addr = 18446744073709545591LLU; // 99999998f1'''''''''''''''
9920899249 break;
9920999250 }
99210- case 18446744073709545596LLU: // 99999998f6'''''''''''''''
99251+ case 18446744073709545591LLU: // 99999998f1'''''''''''''''
9921199252 {
9921299253 {
9921399254 uint64_t arg = 0LLU;
@@ -99251,7 +99292,7 @@
9925199292 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9925299293 }
9925399294 // ACCUMULATE ARGUMENTS - END
99254- uint64_t return_to = 18446744073709545593LLU;
99295+ uint64_t return_to = 18446744073709545588LLU;
9925599296 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0));
9925699297 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9925799298 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99260,12 +99301,12 @@
9926099301 state.addr = 587881344696777536LLU; // emitdestr_
9926199302 break;
9926299303 }
99263- case 18446744073709545593LLU: // 99999998f3'''''''''''''''
99304+ case 18446744073709545588LLU: // 99999998fy'''''''''''''''
9926499305 {
99265- state.addr = 18446744073709545594LLU; // 99999998f4'''''''''''''''
99306+ state.addr = 18446744073709545589LLU; // 99999998fz'''''''''''''''
9926699307 break;
9926799308 }
99268- case 18446744073709545594LLU: // 99999998f4'''''''''''''''
99309+ case 18446744073709545589LLU: // 99999998fz'''''''''''''''
9926999310 {
9927099311 fprintf(stdout, "%s", "\n // RELEASE temporary destructor-variable");
9927199312 {
@@ -99290,7 +99331,7 @@
9929099331 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9929199332 }
9929299333 // ACCUMULATE ARGUMENTS - END
99293- uint64_t return_to = 18446744073709545590LLU;
99334+ uint64_t return_to = 18446744073709545585LLU;
9929499335 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9929599336 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9929699337 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99299,12 +99340,12 @@
9929999340 state.addr = 587881357748664875LLU; // emitpoptmp
9930099341 break;
9930199342 }
99302- case 18446744073709545590LLU: // 99999998f0'''''''''''''''
99343+ case 18446744073709545585LLU: // 99999998fv'''''''''''''''
9930399344 {
99304- state.addr = 18446744073709545591LLU; // 99999998f1'''''''''''''''
99345+ state.addr = 18446744073709545586LLU; // 99999998fw'''''''''''''''
9930599346 break;
9930699347 }
99307- case 18446744073709545591LLU: // 99999998f1'''''''''''''''
99348+ case 18446744073709545586LLU: // 99999998fw'''''''''''''''
9930899349 {
9930999350 // ACCUMULATE ARGUMENTS - BEGIN
9931099351 {
@@ -99320,7 +99361,7 @@
9932099361 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9932199362 }
9932299363 // ACCUMULATE ARGUMENTS - END
99323- uint64_t return_to = 18446744073709545588LLU;
99364+ uint64_t return_to = 18446744073709545583LLU;
9932499365 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9932599366 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9932699367 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99329,20 +99370,20 @@
9932999370 state.addr = 876449629800090048LLU; // unvirtual_
9933099371 break;
9933199372 }
99332- case 18446744073709545588LLU: // 99999998fy'''''''''''''''
99373+ case 18446744073709545583LLU: // 99999998ft'''''''''''''''
9933399374 {
99334- state.addr = 18446744073709545589LLU; // 99999998fz'''''''''''''''
99375+ state.addr = 18446744073709545584LLU; // 99999998fu'''''''''''''''
9933599376 break;
9933699377 }
99337- case 18446744073709545589LLU: // 99999998fz'''''''''''''''
99378+ case 18446744073709545584LLU: // 99999998fu'''''''''''''''
9933899379 {
9933999380 // variable u64 level_____ goes out of scope
9934099381 // emitted destructur for type u64
9934199382 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 27
99342- state.addr = 18446744073709545592LLU; // 99999998f2'''''''''''''''
99383+ state.addr = 18446744073709545587LLU; // 99999998fx'''''''''''''''
9934399384 break;
9934499385 }
99345- case 18446744073709545592LLU: // 99999998f2'''''''''''''''
99386+ case 18446744073709545587LLU: // 99999998fx'''''''''''''''
9934699387 {
9934799388 --/*elemcount_*/*LOCAL_ACCESS(heap.data, 26LLU, 20LLU);
9934899389 // variable u64 INDIRECT__ goes out of scope
@@ -99356,10 +99397,10 @@
9935699397 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference elemidx___ at 24
9935799398 // parameter-reference elemdef___ elemtype__ goes out of scope
9935899399 // parameter-reference variant___ constr____ goes out of scope
99359- state.addr = 18446744073709545606LLU; // 99999998gF'''''''''''''''
99400+ state.addr = 18446744073709545601LLU; // 99999998gA'''''''''''''''
9936099401 break;
9936199402 }
99362- case 18446744073709545605LLU: // 99999998gE'''''''''''''''
99403+ case 18446744073709545600LLU: // 99999998g_'''''''''''''''
9936399404 {
9936499405 fprintf(stdout, "%s", "\n // RELEASE destructor-argument");
9936599406 {
@@ -99384,7 +99425,7 @@
9938499425 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9938599426 }
9938699427 // ACCUMULATE ARGUMENTS - END
99387- uint64_t return_to = 18446744073709545585LLU;
99428+ uint64_t return_to = 18446744073709545580LLU;
9938899429 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9938999430 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9939099431 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99393,20 +99434,20 @@
9939399434 state.addr = 587881357748664875LLU; // emitpoptmp
9939499435 break;
9939599436 }
99396- case 18446744073709545585LLU: // 99999998fv'''''''''''''''
99437+ case 18446744073709545580LLU: // 99999998fq'''''''''''''''
9939799438 {
99398- state.addr = 18446744073709545586LLU; // 99999998fw'''''''''''''''
99439+ state.addr = 18446744073709545581LLU; // 99999998fr'''''''''''''''
9939999440 break;
9940099441 }
99401- case 18446744073709545586LLU: // 99999998fw'''''''''''''''
99442+ case 18446744073709545581LLU: // 99999998fr'''''''''''''''
9940299443 {
9940399444 // variable u64 level_____ goes out of scope
9940499445 // emitted destructur for type u64
9940599446 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 22
99406- state.addr = 18446744073709545587LLU; // 99999998fx'''''''''''''''
99447+ state.addr = 18446744073709545582LLU; // 99999998fs'''''''''''''''
9940799448 break;
9940899449 }
99409- case 18446744073709545587LLU: // 99999998fx'''''''''''''''
99450+ case 18446744073709545582LLU: // 99999998fs'''''''''''''''
9941099451 {
9941199452 // ACCUMULATE ARGUMENTS - BEGIN
9941299453 {
@@ -99422,7 +99463,7 @@
9942299463 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9942399464 }
9942499465 // ACCUMULATE ARGUMENTS - END
99425- uint64_t return_to = 18446744073709545583LLU;
99466+ uint64_t return_to = 18446744073709545578LLU;
9942699467 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
9942799468 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9942899469 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99431,12 +99472,12 @@
9943199472 state.addr = 587881353282000896LLU; // emitleave_
9943299473 break;
9943399474 }
99434- case 18446744073709545583LLU: // 99999998ft'''''''''''''''
99475+ case 18446744073709545578LLU: // 99999998fo'''''''''''''''
9943599476 {
99436- state.addr = 18446744073709545584LLU; // 99999998fu'''''''''''''''
99477+ state.addr = 18446744073709545579LLU; // 99999998fp'''''''''''''''
9943799478 break;
9943899479 }
99439- case 18446744073709545584LLU: // 99999998fu'''''''''''''''
99480+ case 18446744073709545579LLU: // 99999998fp'''''''''''''''
9944099481 {
9944199482 // variable u64 elemcount_ goes out of scope
9944299483 // emitted destructur for type u64
@@ -99452,10 +99493,10 @@
9945299493 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizelimit_ at 18
9945399494 // parameter-reference variant___ constr____ goes out of scope
9945499495 // parameter list<variant___> constrs___ goes out of scope
99455- state.addr = 18446744073709545610LLU; // 99999998gJ'''''''''''''''
99496+ state.addr = 18446744073709545605LLU; // 99999998gE'''''''''''''''
9945699497 break;
9945799498 }
99458- case 18446744073709545609LLU: // 99999998gI'''''''''''''''
99499+ case 18446744073709545604LLU: // 99999998gD'''''''''''''''
9945999500 {
9946099501 // ACCUMULATE ARGUMENTS - BEGIN
9946199502 {
@@ -99463,7 +99504,7 @@
9946399504 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9946499505 }
9946599506 // ACCUMULATE ARGUMENTS - END
99466- uint64_t return_to = 18446744073709545580LLU;
99507+ uint64_t return_to = 18446744073709545575LLU;
9946799508 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9946899509 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9946999510 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99472,12 +99513,12 @@
9947299513 state.addr = 587881345921715008LLU; // emitenter_
9947399514 break;
9947499515 }
99475- case 18446744073709545580LLU: // 99999998fq'''''''''''''''
99516+ case 18446744073709545575LLU: // 99999998fl'''''''''''''''
9947699517 {
99477- state.addr = 18446744073709545581LLU; // 99999998fr'''''''''''''''
99518+ state.addr = 18446744073709545576LLU; // 99999998fm'''''''''''''''
9947899519 break;
9947999520 }
99480- case 18446744073709545581LLU: // 99999998fr'''''''''''''''
99521+ case 18446744073709545576LLU: // 99999998fm'''''''''''''''
9948199522 {
9948299523 {
9948399524 uint64_t arg = 1LLU;
@@ -99514,7 +99555,7 @@
9951499555 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9951599556 }
9951699557 // ACCUMULATE ARGUMENTS - END
99517- uint64_t return_to = 18446744073709545576LLU;
99558+ uint64_t return_to = 18446744073709545571LLU;
9951899559 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9951999560 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9952099561 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99523,21 +99564,21 @@
9952399564 state.addr = 587881359725559808LLU; // emitref___
9952499565 break;
9952599566 }
99526- case 18446744073709545576LLU: // 99999998fm'''''''''''''''
99567+ case 18446744073709545571LLU: // 99999998fh'''''''''''''''
9952799568 {
99528- state.addr = 18446744073709545577LLU; // 99999998fn'''''''''''''''
99569+ state.addr = 18446744073709545572LLU; // 99999998fi'''''''''''''''
9952999570 break;
9953099571 }
99531- case 18446744073709545577LLU: // 99999998fn'''''''''''''''
99572+ case 18446744073709545572LLU: // 99999998fi'''''''''''''''
9953299573 {
9953399574 fprintf(stdout, "%s", ");");
9953499575 // variable u64 zero______ goes out of scope
9953599576 // emitted destructur for type u64
9953699577 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference zero______ at 19
99537- state.addr = 18446744073709545578LLU; // 99999998fo'''''''''''''''
99578+ state.addr = 18446744073709545573LLU; // 99999998fj'''''''''''''''
9953899579 break;
9953999580 }
99540- case 18446744073709545578LLU: // 99999998fo'''''''''''''''
99581+ case 18446744073709545573LLU: // 99999998fj'''''''''''''''
9954199582 {
9954299583 {
9954399584 uint64_t arg = 0LLU;
@@ -99562,7 +99603,7 @@
9956299603 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9956399604 }
9956499605 // ACCUMULATE ARGUMENTS - END
99565- uint64_t return_to = 18446744073709545573LLU;
99606+ uint64_t return_to = 18446744073709545568LLU;
9956699607 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
9956799608 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9956899609 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99571,21 +99612,21 @@
9957199612 state.addr = 587881359725559808LLU; // emitref___
9957299613 break;
9957399614 }
99574- case 18446744073709545573LLU: // 99999998fj'''''''''''''''
99615+ case 18446744073709545568LLU: // 99999998fe'''''''''''''''
9957599616 {
99576- state.addr = 18446744073709545574LLU; // 99999998fk'''''''''''''''
99617+ state.addr = 18446744073709545569LLU; // 99999998ff'''''''''''''''
9957799618 break;
9957899619 }
99579- case 18446744073709545574LLU: // 99999998fk'''''''''''''''
99620+ case 18446744073709545569LLU: // 99999998ff'''''''''''''''
9958099621 {
9958199622 fprintf(stdout, "%s", " = type_data.elem1;");
9958299623 // variable u64 zero______ goes out of scope
9958399624 // emitted destructur for type u64
9958499625 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference zero______ at 19
99585- state.addr = 18446744073709545575LLU; // 99999998fl'''''''''''''''
99626+ state.addr = 18446744073709545570LLU; // 99999998fg'''''''''''''''
9958699627 break;
9958799628 }
99588- case 18446744073709545575LLU: // 99999998fl'''''''''''''''
99629+ case 18446744073709545570LLU: // 99999998fg'''''''''''''''
9958999630 {
9959099631 // variable u64 remainsize goes out of scope
9959199632 // emitted destructur for type u64
@@ -99596,10 +99637,10 @@
9959699637 // variable u64 destrargsz goes out of scope
9959799638 // emitted destructur for type u64
9959899639 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destrargsz at 16
99599- state.addr = 18446744073709545579LLU; // 99999998fp'''''''''''''''
99640+ state.addr = 18446744073709545574LLU; // 99999998fk'''''''''''''''
9960099641 break;
9960199642 }
99602- case 18446744073709545579LLU: // 99999998fp'''''''''''''''
99643+ case 18446744073709545574LLU: // 99999998fk'''''''''''''''
9960399644 {
9960499645 fprintf(stdout, "%s", "\n state.addr = ");
9960599646 // ACCUMULATE ARGUMENTS - BEGIN
@@ -99608,7 +99649,7 @@
9960899649 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9960999650 }
9961099651 // ACCUMULATE ARGUMENTS - END
99611- uint64_t return_to = 18446744073709545571LLU;
99652+ uint64_t return_to = 18446744073709545566LLU;
9961299653 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9961399654 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9961499655 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99617,12 +99658,12 @@
9961799658 state.addr = 787446708198178816LLU; // printnr___
9961899659 break;
9961999660 }
99620- case 18446744073709545571LLU: // 99999998fh'''''''''''''''
99661+ case 18446744073709545566LLU: // 99999998fc'''''''''''''''
9962199662 {
99622- state.addr = 18446744073709545572LLU; // 99999998fi'''''''''''''''
99663+ state.addr = 18446744073709545567LLU; // 99999998fd'''''''''''''''
9962399664 break;
9962499665 }
99625- case 18446744073709545572LLU: // 99999998fi'''''''''''''''
99666+ case 18446744073709545567LLU: // 99999998fd'''''''''''''''
9962699667 {
9962799668 fprintf(stdout, "%s", " + type_data.elem0;");
9962899669 {
@@ -99635,7 +99676,7 @@
9963599676 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9963699677 }
9963799678 // ACCUMULATE ARGUMENTS - END
99638- uint64_t return_to = 18446744073709545568LLU;
99679+ uint64_t return_to = 18446744073709545563LLU;
9963999680 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9964099681 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9964199682 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99644,33 +99685,33 @@
9964499685 state.addr = 587881351406074923LLU; // emitjumpup
9964599686 break;
9964699687 }
99647- case 18446744073709545568LLU: // 99999998fe'''''''''''''''
99688+ case 18446744073709545563LLU: // 99999998f$'''''''''''''''
9964899689 {
99649- state.addr = 18446744073709545569LLU; // 99999998ff'''''''''''''''
99690+ state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
9965099691 break;
9965199692 }
99652- case 18446744073709545569LLU: // 99999998ff'''''''''''''''
99693+ case 18446744073709545564LLU: // 99999998fa'''''''''''''''
9965399694 {
9965499695 // variable u64 level_____ goes out of scope
9965599696 // emitted destructur for type u64
9965699697 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 16
99657- state.addr = 18446744073709545570LLU; // 99999998fg'''''''''''''''
99698+ state.addr = 18446744073709545565LLU; // 99999998fb'''''''''''''''
9965899699 break;
9965999700 }
99660- case 18446744073709545570LLU: // 99999998fg'''''''''''''''
99701+ case 18446744073709545565LLU: // 99999998fb'''''''''''''''
9966199702 {
99662- state.addr = 18446744073709545582LLU; // 99999998fs'''''''''''''''
99703+ state.addr = 18446744073709545577LLU; // 99999998fn'''''''''''''''
9966399704 break;
9966499705 }
99665- case 18446744073709545582LLU: // 99999998fs'''''''''''''''
99706+ case 18446744073709545577LLU: // 99999998fn'''''''''''''''
9966699707 {
9966799708 // variable u64 DESTRADDR_ goes out of scope
9966899709 // emitted destructur for type u64
9966999710 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference DESTRADDR_ at 15
99670- state.addr = 18446744073709545613LLU; // 99999998gM'''''''''''''''
99711+ state.addr = 18446744073709545608LLU; // 99999998gH'''''''''''''''
9967199712 break;
9967299713 }
99673- case 18446744073709545613LLU: // 99999998gM'''''''''''''''
99714+ case 18446744073709545608LLU: // 99999998gH'''''''''''''''
9967499715 {
9967599716 // variable u64 maxheapsz_ goes out of scope
9967699717 // emitted destructur for type u64
@@ -99680,14 +99721,14 @@
9968099721 (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr_ at 13
9968199722 // variable list<variant___> constrs___ goes out of scope
9968299723 // emitted destructur for type list<variant___>
99683- state.addr = 18446744073709545566LLU; // 99999998fc'''''''''''''''
99724+ state.addr = 18446744073709545561LLU; // 99999998fY'''''''''''''''
9968499725 break;
9968599726 }
99686- case 18446744073709545566LLU: // 99999998fc'''''''''''''''
99727+ case 18446744073709545561LLU: // 99999998fY'''''''''''''''
9968799728 {
9968899729 if(!*LOCAL_ACCESS(heap.data, 12LLU, 11LLU)/*list*/)
9968999730 {
99690- state.addr = 18446744073709545567LLU; // 99999998fd'''''''''''''''
99731+ state.addr = 18446744073709545562LLU; // 99999998fZ'''''''''''''''
9969199732 break;
9969299733 }
9969399734 // temporary list-element
@@ -99701,7 +99742,7 @@
9970199742 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9970299743 }
9970399744 // ACCUMULATE ARGUMENTS - END
99704- uint64_t return_to = 18446744073709545565LLU;
99745+ uint64_t return_to = 18446744073709545560LLU;
9970599746 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9970699747 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9970799748 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99710,14 +99751,14 @@
9971099751 state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
9971199752 break;
9971299753 }
99713- case 18446744073709545565LLU: // 99999998fb'''''''''''''''
99754+ case 18446744073709545560LLU: // 99999998fX'''''''''''''''
9971499755 {
9971599756 // RELEASE temporary destructor-variable
9971699757 (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
99717- state.addr = 18446744073709545566LLU; // 99999998fc'''''''''''''''
99758+ state.addr = 18446744073709545561LLU; // 99999998fY'''''''''''''''
9971899759 break;
9971999760 }
99720- case 18446744073709545567LLU: // 99999998fd'''''''''''''''
99761+ case 18446744073709545562LLU: // 99999998fZ'''''''''''''''
9972199762 {
9972299763 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference constrs___ at 12
9972399764 // variable u64 union_id__ goes out of scope
@@ -99725,10 +99766,10 @@
9972599766 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference union_id__ at 11
9972699767 heap.availilable_size_for_dynamic_objects += 0LLU;
9972799768 heap.availilable_size_for_dynamic_objects += 0LLU;
99728- state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
99769+ state.addr = 18446744073709545559LLU; // 99999998fW'''''''''''''''
9972999770 break;
9973099771 }
99731- case 18446744073709545680LLU: // 99999998hP'''''''''''''''
99772+ case 18446744073709545675LLU: // 99999998hK'''''''''''''''
9973299773 {
9973399774 {
9973499775 uint64_t arg = 0LLU;
@@ -99767,10 +99808,10 @@
9976799808 LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9976899809 }
9976999810 /*isunsafe__*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /*isunsafe__*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*def_id____*/*LOCAL_ACCESS(heap.data, 19LLU, 7LLU);
99770- state.addr = /*isunsafe__*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709545562LLU : 18446744073709545561LLU;
99811+ state.addr = /*isunsafe__*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709545557LLU : 18446744073709545556LLU;
9977199812 break;
9977299813 }
99773- case 18446744073709545562LLU: // 99999998fZ'''''''''''''''
99814+ case 18446744073709545557LLU: // 99999998fU'''''''''''''''
9977499815 {
9977599816 *LOCAL_ACCESS(heap.data, 19LLU, 12LLU) = 0LLU;
9977699817
@@ -99780,7 +99821,7 @@
9978099821 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9978199822 }
9978299823 // ACCUMULATE ARGUMENTS - END
99783- uint64_t return_to = 18446744073709545559LLU;
99824+ uint64_t return_to = 18446744073709545554LLU;
9978499825 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
9978599826 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
9978699827 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99789,27 +99830,27 @@
9978999830 state.addr = 839519719621918720LLU; // skipws____
9979099831 break;
9979199832 }
99792- case 18446744073709545559LLU: // 99999998fW'''''''''''''''
99833+ case 18446744073709545554LLU: // 99999998fR'''''''''''''''
9979399834 {
99794- state.addr = 18446744073709545560LLU; // 99999998fX'''''''''''''''
99835+ state.addr = 18446744073709545555LLU; // 99999998fS'''''''''''''''
9979599836 break;
9979699837 }
99797- case 18446744073709545560LLU: // 99999998fX'''''''''''''''
99838+ case 18446744073709545555LLU: // 99999998fS'''''''''''''''
9979899839 {
9979999840 /*def_id____*/*LOCAL_ACCESS(heap.data, 19LLU, 7LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 5LLU)));
9980099841 heap.availilable_size_for_dynamic_objects += 0LLU;
9980199842 heap.availilable_size_for_dynamic_objects += 0LLU;
99802- state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
99843+ state.addr = 18446744073709545553LLU; // 99999998fQ'''''''''''''''
9980399844 break;
9980499845 }
99805- case 18446744073709545561LLU: // 99999998fY'''''''''''''''
99846+ case 18446744073709545556LLU: // 99999998fT'''''''''''''''
9980699847 {
9980799848 *LOCAL_ACCESS(heap.data, 19LLU, 12LLU) = 1LLU;
9980899849
99809- state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
99850+ state.addr = 18446744073709545553LLU; // 99999998fQ'''''''''''''''
9981099851 break;
9981199852 }
99812- case 18446744073709545558LLU: // 99999998fV'''''''''''''''
99853+ case 18446744073709545553LLU: // 99999998fQ'''''''''''''''
9981399854 {
9981499855 {
9981599856 uint64_t arg = 552432823529504768LLU;
@@ -99831,38 +99872,38 @@
9983199872 LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9983299873 }
9983399874 /*istotal___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*istotal___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) == /*def_id____*/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU);
99834- state.addr = /*iscomplete*/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU) ? 18446744073709545556LLU : 18446744073709545555LLU;
99875+ state.addr = /*iscomplete*/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU) ? 18446744073709545551LLU : 18446744073709545550LLU;
9983599876 break;
9983699877 }
99837- case 18446744073709545556LLU: // 99999998fT'''''''''''''''
99878+ case 18446744073709545551LLU: // 99999998fO'''''''''''''''
9983899879 {
9983999880 *LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 1LLU;
9984099881
9984199882 heap.availilable_size_for_dynamic_objects += 0LLU;
9984299883 heap.availilable_size_for_dynamic_objects += 0LLU;
99843- state.addr = 18446744073709545554LLU; // 99999998fR'''''''''''''''
99884+ state.addr = 18446744073709545549LLU; // 99999998fM'''''''''''''''
9984499885 break;
9984599886 }
99846- case 18446744073709545555LLU: // 99999998fS'''''''''''''''
99887+ case 18446744073709545550LLU: // 99999998fN'''''''''''''''
9984799888 {
99848- state.addr = /*isfinite__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545553LLU : 18446744073709545552LLU;
99889+ state.addr = /*isfinite__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545548LLU : 18446744073709545547LLU;
9984999890 break;
9985099891 }
99851- case 18446744073709545553LLU: // 99999998fQ'''''''''''''''
99892+ case 18446744073709545548LLU: // 99999998fL'''''''''''''''
9985299893 {
9985399894 *LOCAL_ACCESS(heap.data, 23LLU, 10LLU) = 1LLU;
9985499895
9985599896 heap.availilable_size_for_dynamic_objects += 0LLU;
9985699897 heap.availilable_size_for_dynamic_objects += 0LLU;
99857- state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
99898+ state.addr = 18446744073709545546LLU; // 99999998fJ'''''''''''''''
9985899899 break;
9985999900 }
99860- case 18446744073709545552LLU: // 99999998fP'''''''''''''''
99901+ case 18446744073709545547LLU: // 99999998fK'''''''''''''''
9986199902 {
99862- state.addr = /*ispartial_*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545550LLU : 18446744073709545549LLU;
99903+ state.addr = /*ispartial_*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545545LLU : 18446744073709545544LLU;
9986399904 break;
9986499905 }
99865- case 18446744073709545550LLU: // 99999998fN'''''''''''''''
99906+ case 18446744073709545545LLU: // 99999998fI'''''''''''''''
9986699907 {
9986799908 *LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 0LLU;
9986899909
@@ -99870,15 +99911,15 @@
9987099911
9987199912 heap.availilable_size_for_dynamic_objects += 0LLU;
9987299913 heap.availilable_size_for_dynamic_objects += 0LLU;
99873- state.addr = 18446744073709545548LLU; // 99999998fL'''''''''''''''
99914+ state.addr = 18446744073709545543LLU; // 99999998fG'''''''''''''''
9987499915 break;
9987599916 }
99876- case 18446744073709545549LLU: // 99999998fM'''''''''''''''
99917+ case 18446744073709545544LLU: // 99999998fH'''''''''''''''
9987799918 {
99878- state.addr = /*istotal___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545547LLU : 18446744073709545546LLU;
99919+ state.addr = /*istotal___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545542LLU : 18446744073709545541LLU;
9987999920 break;
9988099921 }
99881- case 18446744073709545547LLU: // 99999998fK'''''''''''''''
99922+ case 18446744073709545542LLU: // 99999998fF'''''''''''''''
9988299923 {
9988399924 *LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 1LLU;
9988499925
@@ -99886,10 +99927,10 @@
9988699927
9988799928 heap.availilable_size_for_dynamic_objects += 0LLU;
9988899929 heap.availilable_size_for_dynamic_objects += 0LLU;
99889- state.addr = 18446744073709545545LLU; // 99999998fI'''''''''''''''
99930+ state.addr = 18446744073709545540LLU; // 99999998fD'''''''''''''''
9989099931 break;
9989199932 }
99892- case 18446744073709545546LLU: // 99999998fJ'''''''''''''''
99933+ case 18446744073709545541LLU: // 99999998fE'''''''''''''''
9989399934 {
9989499935 fprintf(stderr, "%s", "missing property before ");
9989599936 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU));
@@ -99898,25 +99939,25 @@
9989899939 fprintf(stderr, "%s\n", "");
9989999940 exit(-1);
9990099941 }
99901- state.addr = 18446744073709545545LLU; // 99999998fI'''''''''''''''
99942+ state.addr = 18446744073709545540LLU; // 99999998fD'''''''''''''''
9990299943 break;
9990399944 }
99904- case 18446744073709545545LLU: // 99999998fI'''''''''''''''
99945+ case 18446744073709545540LLU: // 99999998fD'''''''''''''''
9990599946 {
99906- state.addr = 18446744073709545548LLU; // 99999998fL'''''''''''''''
99947+ state.addr = 18446744073709545543LLU; // 99999998fG'''''''''''''''
9990799948 break;
9990899949 }
99909- case 18446744073709545548LLU: // 99999998fL'''''''''''''''
99950+ case 18446744073709545543LLU: // 99999998fG'''''''''''''''
9991099951 {
99911- state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
99952+ state.addr = 18446744073709545546LLU; // 99999998fJ'''''''''''''''
9991299953 break;
9991399954 }
99914- case 18446744073709545551LLU: // 99999998fO'''''''''''''''
99955+ case 18446744073709545546LLU: // 99999998fJ'''''''''''''''
9991599956 {
99916- state.addr = 18446744073709545554LLU; // 99999998fR'''''''''''''''
99957+ state.addr = 18446744073709545549LLU; // 99999998fM'''''''''''''''
9991799958 break;
9991899959 }
99919- case 18446744073709545554LLU: // 99999998fR'''''''''''''''
99960+ case 18446744073709545549LLU: // 99999998fM'''''''''''''''
9992099961 {
9992199962 // variable u64 istotal___ goes out of scope
9992299963 // emitted destructur for type u64
@@ -99930,18 +99971,18 @@
9993099971 // variable u64 iscomplete goes out of scope
9993199972 // emitted destructur for type u64
9993299973 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference iscomplete at 20
99933- state.addr = 18446744073709545557LLU; // 99999998fU'''''''''''''''
99974+ state.addr = 18446744073709545552LLU; // 99999998fP'''''''''''''''
9993499975 break;
9993599976 }
99936- case 18446744073709545557LLU: // 99999998fU'''''''''''''''
99977+ case 18446744073709545552LLU: // 99999998fP'''''''''''''''
9993799978 {
9993899979 // variable u64 isunsafe__ goes out of scope
9993999980 // emitted destructur for type u64
9994099981 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference isunsafe__ at 19
99941- state.addr = 18446744073709545563LLU; // 99999998f$'''''''''''''''
99982+ state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
9994299983 break;
9994399984 }
99944- case 18446744073709545563LLU: // 99999998f$'''''''''''''''
99985+ case 18446744073709545558LLU: // 99999998fV'''''''''''''''
9994599986 {
9994699987 {
9994799988 uint64_t arg = 40LLU;
@@ -99957,7 +99998,7 @@
9995799998 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
9995899999 }
99959100000 // ACCUMULATE ARGUMENTS - END
99960- uint64_t return_to = 18446744073709545542LLU;
100001+ uint64_t return_to = 18446744073709545537LLU;
99961100002 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
99962100003 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
99963100004 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -99966,18 +100007,18 @@
99966100007 state.addr = 839519719621918720LLU; // skipws____
99967100008 break;
99968100009 }
99969- case 18446744073709545542LLU: // 99999998fF'''''''''''''''
100010+ case 18446744073709545537LLU: // 99999998fA'''''''''''''''
99970100011 {
99971- state.addr = 18446744073709545543LLU; // 99999998fG'''''''''''''''
100012+ state.addr = 18446744073709545538LLU; // 99999998fB'''''''''''''''
99972100013 break;
99973100014 }
99974- case 18446744073709545543LLU: // 99999998fG'''''''''''''''
100015+ case 18446744073709545538LLU: // 99999998fB'''''''''''''''
99975100016 {
99976100017 /*found_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 5LLU));
99977- state.addr = /*found_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545541LLU : 18446744073709545540LLU;
100018+ state.addr = /*found_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545536LLU : 18446744073709545535LLU;
99978100019 break;
99979100020 }
99980- case 18446744073709545541LLU: // 99999998fE'''''''''''''''
100021+ case 18446744073709545536LLU: // 99999998f_'''''''''''''''
99981100022 {
99982100023 // ACCUMULATE ARGUMENTS - BEGIN
99983100024 {
@@ -99997,7 +100038,7 @@
99997100038 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
99998100039 }
99999100040 // ACCUMULATE ARGUMENTS - END
100000- uint64_t return_to = 18446744073709545538LLU;
100041+ uint64_t return_to = 18446744073709545533LLU;
100001100042 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
100002100043 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100003100044 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100006,12 +100047,12 @@
100006100047 state.addr = 782701543567846272LLU; // parseress_
100007100048 break;
100008100049 }
100009- case 18446744073709545538LLU: // 99999998fB'''''''''''''''
100050+ case 18446744073709545533LLU: // 99999998e7'''''''''''''''
100010100051 {
100011- state.addr = 18446744073709545539LLU; // 99999998fC'''''''''''''''
100052+ state.addr = 18446744073709545534LLU; // 99999998e8'''''''''''''''
100012100053 break;
100013100054 }
100014- case 18446744073709545539LLU: // 99999998fC'''''''''''''''
100055+ case 18446744073709545534LLU: // 99999998e8'''''''''''''''
100015100056 {
100016100057 {
100017100058 uint64_t arg = 0LLU;
@@ -100022,15 +100063,15 @@
100022100063 // variable u64 resscount_ goes out of scope
100023100064 // emitted destructur for type u64
100024100065 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resscount_ at 21
100025- state.addr = 18446744073709545537LLU; // 99999998fA'''''''''''''''
100066+ state.addr = 18446744073709545532LLU; // 99999998e6'''''''''''''''
100026100067 break;
100027100068 }
100028- case 18446744073709545537LLU: // 99999998fA'''''''''''''''
100069+ case 18446744073709545532LLU: // 99999998e6'''''''''''''''
100029100070 {
100030- state.addr = 18446744073709545540LLU; // 99999998fD'''''''''''''''
100071+ state.addr = 18446744073709545535LLU; // 99999998e9'''''''''''''''
100031100072 break;
100032100073 }
100033- case 18446744073709545540LLU: // 99999998fD'''''''''''''''
100074+ case 18446744073709545535LLU: // 99999998e9'''''''''''''''
100034100075 {
100035100076 // variable u64 found_____ goes out of scope
100036100077 // emitted destructur for type u64
@@ -100038,10 +100079,10 @@
100038100079 // variable u64 sym_______ goes out of scope
100039100080 // emitted destructur for type u64
100040100081 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 19
100041- state.addr = 18446744073709545544LLU; // 99999998fH'''''''''''''''
100082+ state.addr = 18446744073709545539LLU; // 99999998fC'''''''''''''''
100042100083 break;
100043100084 }
100044- case 18446744073709545544LLU: // 99999998fH'''''''''''''''
100085+ case 18446744073709545539LLU: // 99999998fC'''''''''''''''
100045100086 {
100046100087 // ACCUMULATE ARGUMENTS - BEGIN
100047100088 {
@@ -100049,7 +100090,7 @@
100049100090 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100050100091 }
100051100092 // ACCUMULATE ARGUMENTS - END
100052- uint64_t return_to = 18446744073709545535LLU;
100093+ uint64_t return_to = 18446744073709545530LLU;
100053100094 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100054100095 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100055100096 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100058,12 +100099,12 @@
100058100099 state.addr = 839519719621918720LLU; // skipws____
100059100100 break;
100060100101 }
100061- case 18446744073709545535LLU: // 99999998e9'''''''''''''''
100102+ case 18446744073709545530LLU: // 99999998e4'''''''''''''''
100062100103 {
100063- state.addr = 18446744073709545536LLU; // 99999998f_'''''''''''''''
100104+ state.addr = 18446744073709545531LLU; // 99999998e5'''''''''''''''
100064100105 break;
100065100106 }
100066- case 18446744073709545536LLU: // 99999998f_'''''''''''''''
100107+ case 18446744073709545531LLU: // 99999998e5'''''''''''''''
100067100108 {
100068100109 /*def_id____*/*LOCAL_ACCESS(heap.data, 18LLU, 7LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)));
100069100110 {
@@ -100084,7 +100125,7 @@
100084100125 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100085100126 }
100086100127 // ACCUMULATE ARGUMENTS - END
100087- uint64_t return_to = 18446744073709545533LLU;
100128+ uint64_t return_to = 18446744073709545528LLU;
100088100129 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100089100130 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100090100131 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100093,18 +100134,18 @@
100093100134 state.addr = 839519719621918720LLU; // skipws____
100094100135 break;
100095100136 }
100096- case 18446744073709545533LLU: // 99999998e7'''''''''''''''
100137+ case 18446744073709545528LLU: // 99999998e2'''''''''''''''
100097100138 {
100098- state.addr = 18446744073709545534LLU; // 99999998e8'''''''''''''''
100139+ state.addr = 18446744073709545529LLU; // 99999998e3'''''''''''''''
100099100140 break;
100100100141 }
100101- case 18446744073709545534LLU: // 99999998e8'''''''''''''''
100142+ case 18446744073709545529LLU: // 99999998e3'''''''''''''''
100102100143 {
100103100144 /*matchsym__*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 5LLU));
100104- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709545532LLU : 18446744073709545531LLU;
100145+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709545527LLU : 18446744073709545526LLU;
100105100146 break;
100106100147 }
100107- case 18446744073709545532LLU: // 99999998e6'''''''''''''''
100148+ case 18446744073709545527LLU: // 99999998e1'''''''''''''''
100108100149 {
100109100150 {
100110100151 uint64_t arg = 0LLU;
@@ -100128,7 +100169,7 @@
100128100169 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100129100170 }
100130100171 // ACCUMULATE ARGUMENTS - END
100131- uint64_t return_to = 18446744073709545529LLU;
100172+ uint64_t return_to = 18446744073709545524LLU;
100132100173 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
100133100174 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100134100175 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100137,12 +100178,12 @@
100137100178 state.addr = 782701543585622638LLU; // parsesigns
100138100179 break;
100139100180 }
100140- case 18446744073709545529LLU: // 99999998e3'''''''''''''''
100181+ case 18446744073709545524LLU: // 99999998ey'''''''''''''''
100141100182 {
100142- state.addr = 18446744073709545530LLU; // 99999998e4'''''''''''''''
100183+ state.addr = 18446744073709545525LLU; // 99999998ez'''''''''''''''
100143100184 break;
100144100185 }
100145- case 18446744073709545530LLU: // 99999998e4'''''''''''''''
100186+ case 18446744073709545525LLU: // 99999998ez'''''''''''''''
100146100187 {
100147100188 *LOCAL_ACCESS(heap.data, 22LLU, 19LLU) = 45LLU;
100148100189
@@ -100152,7 +100193,7 @@
100152100193 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100153100194 }
100154100195 // ACCUMULATE ARGUMENTS - END
100155- uint64_t return_to = 18446744073709545527LLU;
100196+ uint64_t return_to = 18446744073709545522LLU;
100156100197 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100157100198 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100158100199 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100161,33 +100202,33 @@
100161100202 state.addr = 839519719621918720LLU; // skipws____
100162100203 break;
100163100204 }
100164- case 18446744073709545527LLU: // 99999998e1'''''''''''''''
100205+ case 18446744073709545522LLU: // 99999998ew'''''''''''''''
100165100206 {
100166- state.addr = 18446744073709545528LLU; // 99999998e2'''''''''''''''
100207+ state.addr = 18446744073709545523LLU; // 99999998ex'''''''''''''''
100167100208 break;
100168100209 }
100169- case 18446744073709545528LLU: // 99999998e2'''''''''''''''
100210+ case 18446744073709545523LLU: // 99999998ex'''''''''''''''
100170100211 {
100171100212 /*matchsym__*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU));
100172- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709545526LLU : 18446744073709545525LLU;
100213+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709545521LLU : 18446744073709545520LLU;
100173100214 break;
100174100215 }
100175- case 18446744073709545526LLU: // 99999998e0'''''''''''''''
100216+ case 18446744073709545521LLU: // 99999998ev'''''''''''''''
100176100217 {
100177100218 matchid("->", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
100178- state.addr = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU) ? 18446744073709545524LLU : 18446744073709545523LLU;
100219+ state.addr = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU) ? 18446744073709545519LLU : 18446744073709545518LLU;
100179100220 break;
100180100221 }
100181- case 18446744073709545524LLU: // 99999998ey'''''''''''''''
100222+ case 18446744073709545519LLU: // 99999998et'''''''''''''''
100182100223 {
100183100224 {
100184100225 fprintf(stderr, "%s\n", "can't mix (c) f(a) with f :: (a) -> (c) syntax");
100185100226 exit(-1);
100186100227 }
100187- state.addr = 18446744073709545523LLU; // 99999998ex'''''''''''''''
100228+ state.addr = 18446744073709545518LLU; // 99999998es'''''''''''''''
100188100229 break;
100189100230 }
100190- case 18446744073709545523LLU: // 99999998ex'''''''''''''''
100231+ case 18446744073709545518LLU: // 99999998es'''''''''''''''
100191100232 {
100192100233 // ACCUMULATE ARGUMENTS - BEGIN
100193100234 {
@@ -100195,7 +100236,7 @@
100195100236 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100196100237 }
100197100238 // ACCUMULATE ARGUMENTS - END
100198- uint64_t return_to = 18446744073709545520LLU;
100239+ uint64_t return_to = 18446744073709545515LLU;
100199100240 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100200100241 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100201100242 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100204,12 +100245,12 @@
100204100245 state.addr = 839519719621918720LLU; // skipws____
100205100246 break;
100206100247 }
100207- case 18446744073709545520LLU: // 99999998eu'''''''''''''''
100248+ case 18446744073709545515LLU: // 99999998ep'''''''''''''''
100208100249 {
100209- state.addr = 18446744073709545521LLU; // 99999998ev'''''''''''''''
100250+ state.addr = 18446744073709545516LLU; // 99999998eq'''''''''''''''
100210100251 break;
100211100252 }
100212- case 18446744073709545521LLU: // 99999998ev'''''''''''''''
100253+ case 18446744073709545516LLU: // 99999998eq'''''''''''''''
100213100254 {
100214100255 // ACCUMULATE ARGUMENTS - BEGIN
100215100256 {
@@ -100229,7 +100270,7 @@
100229100270 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100230100271 }
100231100272 // ACCUMULATE ARGUMENTS - END
100232- uint64_t return_to = 18446744073709545518LLU;
100273+ uint64_t return_to = 18446744073709545513LLU;
100233100274 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
100234100275 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100235100276 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100238,12 +100279,12 @@
100238100279 state.addr = 782701543567846272LLU; // parseress_
100239100280 break;
100240100281 }
100241- case 18446744073709545518LLU: // 99999998es'''''''''''''''
100282+ case 18446744073709545513LLU: // 99999998en'''''''''''''''
100242100283 {
100243- state.addr = 18446744073709545519LLU; // 99999998et'''''''''''''''
100284+ state.addr = 18446744073709545514LLU; // 99999998eo'''''''''''''''
100244100285 break;
100245100286 }
100246- case 18446744073709545519LLU: // 99999998et'''''''''''''''
100287+ case 18446744073709545514LLU: // 99999998eo'''''''''''''''
100247100288 {
100248100289 {
100249100290 uint64_t arg = 0LLU;
@@ -100254,21 +100295,21 @@
100254100295 // variable u64 resscount_ goes out of scope
100255100296 // emitted destructur for type u64
100256100297 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resscount_ at 23
100257- state.addr = 18446744073709545517LLU; // 99999998er'''''''''''''''
100298+ state.addr = 18446744073709545512LLU; // 99999998em'''''''''''''''
100258100299 break;
100259100300 }
100260- case 18446744073709545517LLU: // 99999998er'''''''''''''''
100301+ case 18446744073709545512LLU: // 99999998em'''''''''''''''
100261100302 {
100262- state.addr = 18446744073709545522LLU; // 99999998ew'''''''''''''''
100303+ state.addr = 18446744073709545517LLU; // 99999998er'''''''''''''''
100263100304 break;
100264100305 }
100265- case 18446744073709545522LLU: // 99999998ew'''''''''''''''
100306+ case 18446744073709545517LLU: // 99999998er'''''''''''''''
100266100307 {
100267100308 list_reverse(heap.data, &/*results___*/*LOCAL_ACCESS(heap.data, 22LLU, 17LLU));
100268- state.addr = 18446744073709545525LLU; // 99999998ez'''''''''''''''
100309+ state.addr = 18446744073709545520LLU; // 99999998eu'''''''''''''''
100269100310 break;
100270100311 }
100271- case 18446744073709545525LLU: // 99999998ez'''''''''''''''
100312+ case 18446744073709545520LLU: // 99999998eu'''''''''''''''
100272100313 {
100273100314 // ACCUMULATE ARGUMENTS - BEGIN
100274100315 {
@@ -100276,7 +100317,7 @@
100276100317 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100277100318 }
100278100319 // ACCUMULATE ARGUMENTS - END
100279- uint64_t return_to = 18446744073709545514LLU;
100320+ uint64_t return_to = 18446744073709545509LLU;
100280100321 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100281100322 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100282100323 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100285,12 +100326,12 @@
100285100326 state.addr = 839519719621918720LLU; // skipws____
100286100327 break;
100287100328 }
100288- case 18446744073709545514LLU: // 99999998eo'''''''''''''''
100329+ case 18446744073709545509LLU: // 99999998ej'''''''''''''''
100289100330 {
100290- state.addr = 18446744073709545515LLU; // 99999998ep'''''''''''''''
100331+ state.addr = 18446744073709545510LLU; // 99999998ek'''''''''''''''
100291100332 break;
100292100333 }
100293- case 18446744073709545515LLU: // 99999998ep'''''''''''''''
100334+ case 18446744073709545510LLU: // 99999998ek'''''''''''''''
100294100335 {
100295100336 /*defbodysz_*/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
100296100337 *LOCAL_ACCESS(heap.data, 22LLU, 15LLU) = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU);
@@ -100301,7 +100342,7 @@
100301100342 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100302100343 }
100303100344 // ACCUMULATE ARGUMENTS - END
100304- uint64_t return_to = 18446744073709545512LLU;
100345+ uint64_t return_to = 18446744073709545507LLU;
100305100346 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100306100347 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100307100348 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100310,18 +100351,18 @@
100310100351 state.addr = 839519719621918720LLU; // skipws____
100311100352 break;
100312100353 }
100313- case 18446744073709545512LLU: // 99999998em'''''''''''''''
100354+ case 18446744073709545507LLU: // 99999998eh'''''''''''''''
100314100355 {
100315- state.addr = 18446744073709545513LLU; // 99999998en'''''''''''''''
100356+ state.addr = 18446744073709545508LLU; // 99999998ei'''''''''''''''
100316100357 break;
100317100358 }
100318- case 18446744073709545513LLU: // 99999998en'''''''''''''''
100359+ case 18446744073709545508LLU: // 99999998ei'''''''''''''''
100319100360 {
100320100361 /*remainheap*/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
100321- state.addr = 18446744073709545516LLU; // 99999998eq'''''''''''''''
100362+ state.addr = 18446744073709545511LLU; // 99999998el'''''''''''''''
100322100363 break;
100323100364 }
100324- case 18446744073709545516LLU: // 99999998eq'''''''''''''''
100365+ case 18446744073709545511LLU: // 99999998el'''''''''''''''
100325100366 {
100326100367 list_reverse(heap.data, &/*signs_____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU));
100327100368 {
@@ -100332,10 +100373,10 @@
100332100373 uint64_t arg = 0;
100333100374 LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
100334100375 }
100335- state.addr = 18446744073709545510LLU; // 99999998ek'''''''''''''''
100376+ state.addr = 18446744073709545505LLU; // 99999998ef'''''''''''''''
100336100377 break;
100337100378 }
100338- case 18446744073709545510LLU: // 99999998ek'''''''''''''''
100379+ case 18446744073709545505LLU: // 99999998ef'''''''''''''''
100339100380 {
100340100381 if(!*LOCAL_ACCESS(heap.data, 24LLU, 22LLU))
100341100382 {
@@ -100342,7 +100383,7 @@
100342100383 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 24
100343100384 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
100344100385 {
100345- state.addr = 18446744073709545509LLU; // 99999998ej'''''''''''''''
100386+ state.addr = 18446744073709545504LLU; // 99999998ee'''''''''''''''
100346100387 break;
100347100388 }
100348100389 }
@@ -100360,10 +100401,10 @@
100360100401 };
100361100402 *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = arg;
100362100403 }
100363- state.addr = 18446744073709545508LLU; // 99999998ei'''''''''''''''
100404+ state.addr = 18446744073709545503LLU; // 99999998ed'''''''''''''''
100364100405 break;
100365100406 }
100366- case 18446744073709545508LLU: // 99999998ei'''''''''''''''
100407+ case 18446744073709545503LLU: // 99999998ed'''''''''''''''
100367100408 {
100368100409 // ACCUMULATE ARGUMENTS - BEGIN
100369100410 {
@@ -100375,7 +100416,7 @@
100375100416 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100376100417 }
100377100418 // ACCUMULATE ARGUMENTS - END
100378- uint64_t return_to = 18446744073709545506LLU;
100419+ uint64_t return_to = 18446744073709545501LLU;
100379100420 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
100380100421 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100381100422 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100384,12 +100425,12 @@
100384100425 state.addr = 861504776686223360LLU; // typecopy__
100385100426 break;
100386100427 }
100387- case 18446744073709545506LLU: // 99999998eg'''''''''''''''
100428+ case 18446744073709545501LLU: // 99999998eb'''''''''''''''
100388100429 {
100389- state.addr = 18446744073709545507LLU; // 99999998eh'''''''''''''''
100430+ state.addr = 18446744073709545502LLU; // 99999998ec'''''''''''''''
100390100431 break;
100391100432 }
100392- case 18446744073709545507LLU: // 99999998eh'''''''''''''''
100433+ case 18446744073709545502LLU: // 99999998ec'''''''''''''''
100393100434 {
100394100435 {
100395100436 uint64_t arg = /*sign______*/*access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 25LLU, 23LLU), 2LLU));
@@ -100407,10 +100448,10 @@
100407100448 };
100408100449 *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = arg;
100409100450 }
100410- state.addr = 18446744073709545505LLU; // 99999998ef'''''''''''''''
100451+ state.addr = 18446744073709545500LLU; // 99999998ea'''''''''''''''
100411100452 break;
100412100453 }
100413- case 18446744073709545505LLU: // 99999998ef'''''''''''''''
100454+ case 18446744073709545500LLU: // 99999998ea'''''''''''''''
100414100455 {
100415100456 // ACCUMULATE ARGUMENTS - BEGIN
100416100457 {
@@ -100422,7 +100463,7 @@
100422100463 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100423100464 }
100424100465 // ACCUMULATE ARGUMENTS - END
100425- uint64_t return_to = 18446744073709545503LLU;
100466+ uint64_t return_to = 18446744073709545498LLU;
100426100467 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
100427100468 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100428100469 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100431,12 +100472,12 @@
100431100472 state.addr = 552664889133754368LLU; // cpbalance_
100432100473 break;
100433100474 }
100434- case 18446744073709545503LLU: // 99999998ed'''''''''''''''
100475+ case 18446744073709545498LLU: // 99999998eZ'''''''''''''''
100435100476 {
100436- state.addr = 18446744073709545504LLU; // 99999998ee'''''''''''''''
100477+ state.addr = 18446744073709545499LLU; // 99999998e$'''''''''''''''
100437100478 break;
100438100479 }
100439- case 18446744073709545504LLU: // 99999998ee'''''''''''''''
100480+ case 18446744073709545499LLU: // 99999998e$'''''''''''''''
100440100481 {
100441100482 {
100442100483 uint64_t arg = /*sign______*/*access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 27LLU, 23LLU), 0LLU));
@@ -100454,15 +100495,15 @@
100454100495 tree_push_move(&heap, 3LLU, &arg, &*LOCAL_ACCESS(heap.data, 29LLU, 27LLU));
100455100496 *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = arg;
100456100497 }
100457- state.addr = 18446744073709545502LLU; // 99999998ec'''''''''''''''
100498+ state.addr = 18446744073709545497LLU; // 99999998eY'''''''''''''''
100458100499 break;
100459100500 }
100460- case 18446744073709545502LLU: // 99999998ec'''''''''''''''
100501+ case 18446744073709545497LLU: // 99999998eY'''''''''''''''
100461100502 {
100462- state.addr = !list_push_move(&heap, &/*par_______*/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU), &/*defpars___*/*LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 11) ? 18446744073709545501LLU : 18446744073709545500LLU;
100503+ state.addr = !list_push_move(&heap, &/*par_______*/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU), &/*defpars___*/*LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 11) ? 18446744073709545496LLU : 18446744073709545495LLU;
100463100504 break;
100464100505 }
100465- case 18446744073709545501LLU: // 99999998eb'''''''''''''''
100506+ case 18446744073709545496LLU: // 99999998eX'''''''''''''''
100466100507 {
100467100508 {
100468100509 uint64_t arg = *LOCAL_ACCESS(heap.data, 29LLU, 28LLU);
@@ -100474,7 +100515,7 @@
100474100515 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100475100516 }
100476100517 // ACCUMULATE ARGUMENTS - END
100477- uint64_t return_to = 18446744073709545498LLU;
100518+ uint64_t return_to = 18446744073709545493LLU;
100478100519 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100479100520 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100480100521 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100483,12 +100524,12 @@
100483100524 state.addr = 819847183515949359LLU; // reportinit
100484100525 break;
100485100526 }
100486- case 18446744073709545498LLU: // 99999998eZ'''''''''''''''
100527+ case 18446744073709545493LLU: // 99999998eU'''''''''''''''
100487100528 {
100488- state.addr = 18446744073709545499LLU; // 99999998e$'''''''''''''''
100529+ state.addr = 18446744073709545494LLU; // 99999998eV'''''''''''''''
100489100530 break;
100490100531 }
100491- case 18446744073709545499LLU: // 99999998e$'''''''''''''''
100532+ case 18446744073709545494LLU: // 99999998eV'''''''''''''''
100492100533 {
100493100534 fprintf(stderr, "%s", "parsing definition, ");
100494100535 {
@@ -100503,7 +100544,7 @@
100503100544 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100504100545 }
100505100546 // ACCUMULATE ARGUMENTS - END
100506- uint64_t return_to = 18446744073709545497LLU;
100547+ uint64_t return_to = 18446744073709545492LLU;
100507100548 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100508100549 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100509100550 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100512,20 +100553,20 @@
100512100553 state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
100513100554 break;
100514100555 }
100515- case 18446744073709545497LLU: // 99999998eY'''''''''''''''
100556+ case 18446744073709545492LLU: // 99999998eT'''''''''''''''
100516100557 {
100517100558 (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par_______ at 30
100518100559 heap.availilable_size_for_dynamic_objects += 0LLU;
100519100560 heap.availilable_size_for_dynamic_objects += 0LLU;
100520- state.addr = 18446744073709545496LLU; // 99999998eX'''''''''''''''
100561+ state.addr = 18446744073709545491LLU; // 99999998eS'''''''''''''''
100521100562 break;
100522100563 }
100523- case 18446744073709545500LLU: // 99999998ea'''''''''''''''
100564+ case 18446744073709545495LLU: // 99999998eW'''''''''''''''
100524100565 {
100525- state.addr = 18446744073709545496LLU; // 99999998eX'''''''''''''''
100566+ state.addr = 18446744073709545491LLU; // 99999998eS'''''''''''''''
100526100567 break;
100527100568 }
100528- case 18446744073709545496LLU: // 99999998eX'''''''''''''''
100569+ case 18446744073709545491LLU: // 99999998eS'''''''''''''''
100529100570 {
100530100571 // variable pardef____ par_______ goes out of scope
100531100572 // (uninitialized -> no destructor-call)
@@ -100544,10 +100585,10 @@
100544100585 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 25
100545100586 // parameter-reference signdef___ sign______ goes out of scope
100546100587 // parameter list<signdef___> signs_____ goes out of scope
100547- state.addr = 18446744073709545510LLU; // 99999998ek'''''''''''''''
100588+ state.addr = 18446744073709545505LLU; // 99999998ef'''''''''''''''
100548100589 break;
100549100590 }
100550- case 18446744073709545509LLU: // 99999998ej'''''''''''''''
100591+ case 18446744073709545504LLU: // 99999998ee'''''''''''''''
100551100592 {
100552100593 {
100553100594 uint64_t arg = 0LLU;
@@ -100558,15 +100599,15 @@
100558100599 // variable u64 argscount_ goes out of scope
100559100600 // emitted destructur for type u64
100560100601 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference argscount_ at 23
100561- state.addr = 18446744073709545495LLU; // 99999998eW'''''''''''''''
100602+ state.addr = 18446744073709545490LLU; // 99999998eR'''''''''''''''
100562100603 break;
100563100604 }
100564- case 18446744073709545495LLU: // 99999998eW'''''''''''''''
100605+ case 18446744073709545490LLU: // 99999998eR'''''''''''''''
100565100606 {
100566- state.addr = 18446744073709545511LLU; // 99999998el'''''''''''''''
100607+ state.addr = 18446744073709545506LLU; // 99999998eg'''''''''''''''
100567100608 break;
100568100609 }
100569- case 18446744073709545511LLU: // 99999998el'''''''''''''''
100610+ case 18446744073709545506LLU: // 99999998eg'''''''''''''''
100570100611 {
100571100612 {
100572100613 uint64_t arg = 0LLU;
@@ -100582,7 +100623,7 @@
100582100623 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100583100624 }
100584100625 // ACCUMULATE ARGUMENTS - END
100585- uint64_t return_to = 18446744073709545492LLU;
100626+ uint64_t return_to = 18446744073709545487LLU;
100586100627 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100587100628 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100588100629 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100591,12 +100632,12 @@
100591100632 state.addr = 839519719621918720LLU; // skipws____
100592100633 break;
100593100634 }
100594- case 18446744073709545492LLU: // 99999998eT'''''''''''''''
100635+ case 18446744073709545487LLU: // 99999998eO'''''''''''''''
100595100636 {
100596- state.addr = 18446744073709545493LLU; // 99999998eU'''''''''''''''
100637+ state.addr = 18446744073709545488LLU; // 99999998eP'''''''''''''''
100597100638 break;
100598100639 }
100599- case 18446744073709545493LLU: // 99999998eU'''''''''''''''
100640+ case 18446744073709545488LLU: // 99999998eP'''''''''''''''
100600100641 {
100601100642 // ACCUMULATE ARGUMENTS - BEGIN
100602100643 {
@@ -100612,7 +100653,7 @@
100612100653 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100613100654 }
100614100655 // ACCUMULATE ARGUMENTS - END
100615- uint64_t return_to = 18446744073709545490LLU;
100656+ uint64_t return_to = 18446744073709545485LLU;
100616100657 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
100617100658 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100618100659 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100621,38 +100662,38 @@
100621100662 state.addr = 728666047794575267LLU; // matchoptch
100622100663 break;
100623100664 }
100624- case 18446744073709545490LLU: // 99999998eR'''''''''''''''
100665+ case 18446744073709545485LLU: // 99999998eM'''''''''''''''
100625100666 {
100626- state.addr = 18446744073709545491LLU; // 99999998eS'''''''''''''''
100667+ state.addr = 18446744073709545486LLU; // 99999998eN'''''''''''''''
100627100668 break;
100628100669 }
100629- case 18446744073709545491LLU: // 99999998eS'''''''''''''''
100670+ case 18446744073709545486LLU: // 99999998eN'''''''''''''''
100630100671 {
100631- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545489LLU : 18446744073709545488LLU;
100672+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545484LLU : 18446744073709545483LLU;
100632100673 break;
100633100674 }
100634- case 18446744073709545489LLU: // 99999998eQ'''''''''''''''
100675+ case 18446744073709545484LLU: // 99999998eL'''''''''''''''
100635100676 {
100636100677 *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0LLU;
100637100678
100638100679 heap.availilable_size_for_dynamic_objects += 0LLU;
100639100680 heap.availilable_size_for_dynamic_objects += 0LLU;
100640- state.addr = 18446744073709545487LLU; // 99999998eO'''''''''''''''
100681+ state.addr = 18446744073709545482LLU; // 99999998eJ'''''''''''''''
100641100682 break;
100642100683 }
100643- case 18446744073709545488LLU: // 99999998eP'''''''''''''''
100684+ case 18446744073709545483LLU: // 99999998eK'''''''''''''''
100644100685 {
100645100686 *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 1LLU;
100646100687
100647- state.addr = 18446744073709545487LLU; // 99999998eO'''''''''''''''
100688+ state.addr = 18446744073709545482LLU; // 99999998eJ'''''''''''''''
100648100689 break;
100649100690 }
100650- case 18446744073709545487LLU: // 99999998eO'''''''''''''''
100691+ case 18446744073709545482LLU: // 99999998eJ'''''''''''''''
100651100692 {
100652- state.addr = 18446744073709545494LLU; // 99999998eV'''''''''''''''
100693+ state.addr = 18446744073709545489LLU; // 99999998eQ'''''''''''''''
100653100694 break;
100654100695 }
100655- case 18446744073709545494LLU: // 99999998eV'''''''''''''''
100696+ case 18446744073709545489LLU: // 99999998eQ'''''''''''''''
100656100697 {
100657100698 {
100658100699 uint64_t arg = 0LLU;
@@ -100700,7 +100741,7 @@
100700100741 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100701100742 }
100702100743 // ACCUMULATE ARGUMENTS - END
100703- uint64_t return_to = 18446744073709545484LLU;
100744+ uint64_t return_to = 18446744073709545479LLU;
100704100745 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0));
100705100746 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100706100747 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100709,12 +100750,12 @@
100709100750 state.addr = 728626598349373440LLU; // makedef___
100710100751 break;
100711100752 }
100712- case 18446744073709545484LLU: // 99999998eL'''''''''''''''
100753+ case 18446744073709545479LLU: // 99999998eG'''''''''''''''
100713100754 {
100714- state.addr = 18446744073709545485LLU; // 99999998eM'''''''''''''''
100755+ state.addr = 18446744073709545480LLU; // 99999998eH'''''''''''''''
100715100756 break;
100716100757 }
100717- case 18446744073709545485LLU: // 99999998eM'''''''''''''''
100758+ case 18446744073709545480LLU: // 99999998eH'''''''''''''''
100718100759 {
100719100760 {
100720100761 uint64_t arg = 1LLU;
@@ -100728,10 +100769,10 @@
100728100769 uint64_t arg = 0;
100729100770 LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg);
100730100771 }
100731- state.addr = 18446744073709545483LLU; // 99999998eK'''''''''''''''
100772+ state.addr = 18446744073709545478LLU; // 99999998eF'''''''''''''''
100732100773 break;
100733100774 }
100734- case 18446744073709545483LLU: // 99999998eK'''''''''''''''
100775+ case 18446744073709545478LLU: // 99999998eF'''''''''''''''
100735100776 {
100736100777 if(!*LOCAL_ACCESS(heap.data, 27LLU, 25LLU))
100737100778 {
@@ -100738,16 +100779,16 @@
100738100779 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 27
100739100780 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 26
100740100781 {
100741- state.addr = 18446744073709545482LLU; // 99999998eJ'''''''''''''''
100782+ state.addr = 18446744073709545477LLU; // 99999998eE'''''''''''''''
100742100783 break;
100743100784 }
100744100785 }
100745100786 /*direct*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = (*LOCAL_ACCESS(heap.data, 27LLU, 25LLU) << 1) + 1LLU;
100746100787 *LOCAL_ACCESS(heap.data, 27LLU, 25LLU) = heap.data[*LOCAL_ACCESS(heap.data, 27LLU, 25LLU)].elem0;
100747- state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545481LLU : 18446744073709545480LLU;
100788+ state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545476LLU : 18446744073709545475LLU;
100748100789 break;
100749100790 }
100750- case 18446744073709545481LLU: // 99999998eI'''''''''''''''
100791+ case 18446744073709545476LLU: // 99999998eD'''''''''''''''
100751100792 {
100752100793 {
100753100794 uint64_t arg = 0LLU;
@@ -100754,10 +100795,10 @@
100754100795 LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
100755100796 }
100756100797 /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU) == /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 0LLU));
100757- state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545479LLU : 18446744073709545478LLU;
100798+ state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545474LLU : 18446744073709545473LLU;
100758100799 break;
100759100800 }
100760- case 18446744073709545479LLU: // 99999998eG'''''''''''''''
100801+ case 18446744073709545474LLU: // 99999998eB'''''''''''''''
100761100802 {
100762100803 *LOCAL_ACCESS(heap.data, 28LLU, 24LLU) = 0LLU;
100763100804
@@ -100775,7 +100816,7 @@
100775100816 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100776100817 }
100777100818 // ACCUMULATE ARGUMENTS - END
100778- uint64_t return_to = 18446744073709545476LLU;
100819+ uint64_t return_to = 18446744073709545471LLU;
100779100820 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
100780100821 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100781100822 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100784,22 +100825,22 @@
100784100825 state.addr = 589059069805989888LLU; // equfndef__
100785100826 break;
100786100827 }
100787- case 18446744073709545476LLU: // 99999998eD'''''''''''''''
100828+ case 18446744073709545471LLU: // 99999998d9'''''''''''''''
100788100829 {
100789- state.addr = 18446744073709545477LLU; // 99999998eE'''''''''''''''
100830+ state.addr = 18446744073709545472LLU; // 99999998e_'''''''''''''''
100790100831 break;
100791100832 }
100792- case 18446744073709545477LLU: // 99999998eE'''''''''''''''
100833+ case 18446744073709545472LLU: // 99999998e_'''''''''''''''
100793100834 {
100794- state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545475LLU : 18446744073709545474LLU;
100835+ state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545470LLU : 18446744073709545469LLU;
100795100836 break;
100796100837 }
100797- case 18446744073709545475LLU: // 99999998eC'''''''''''''''
100838+ case 18446744073709545470LLU: // 99999998d8'''''''''''''''
100798100839 {
100799- state.addr = /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545473LLU : 18446744073709545472LLU;
100840+ state.addr = /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545468LLU : 18446744073709545467LLU;
100800100841 break;
100801100842 }
100802- case 18446744073709545473LLU: // 99999998eA'''''''''''''''
100843+ case 18446744073709545468LLU: // 99999998d6'''''''''''''''
100803100844 {
100804100845 fprintf(stderr, "%s", "re-definition of ");
100805100846 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
@@ -100809,43 +100850,43 @@
100809100850 }
100810100851 heap.availilable_size_for_dynamic_objects += 0LLU;
100811100852 heap.availilable_size_for_dynamic_objects += 0LLU;
100812- state.addr = 18446744073709545471LLU; // 99999998d9'''''''''''''''
100853+ state.addr = 18446744073709545466LLU; // 99999998d4'''''''''''''''
100813100854 break;
100814100855 }
100815- case 18446744073709545472LLU: // 99999998e_'''''''''''''''
100856+ case 18446744073709545467LLU: // 99999998d5'''''''''''''''
100816100857 {
100817- state.addr = /*current___*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545470LLU : 18446744073709545469LLU;
100858+ state.addr = /*current___*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545465LLU : 18446744073709545464LLU;
100818100859 break;
100819100860 }
100820- case 18446744073709545470LLU: // 99999998d8'''''''''''''''
100861+ case 18446744073709545465LLU: // 99999998d3'''''''''''''''
100821100862 {
100822100863 swap(&/*current___*/*LOCAL_ACCESS(heap.data, 28LLU, 23LLU), &/*previous__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU)));
100823100864 heap.availilable_size_for_dynamic_objects += 0LLU;
100824100865 heap.availilable_size_for_dynamic_objects += 0LLU;
100825- state.addr = 18446744073709545468LLU; // 99999998d6'''''''''''''''
100866+ state.addr = 18446744073709545463LLU; // 99999998d1'''''''''''''''
100826100867 break;
100827100868 }
100828- case 18446744073709545469LLU: // 99999998d7'''''''''''''''
100869+ case 18446744073709545464LLU: // 99999998d2'''''''''''''''
100829100870 {
100830100871 fprintf(stderr, "%s", "WARNING: superfluous re-declaration of ");
100831100872 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
100832100873 fprintf(stderr, "%s", "\n");
100833- state.addr = 18446744073709545468LLU; // 99999998d6'''''''''''''''
100874+ state.addr = 18446744073709545463LLU; // 99999998d1'''''''''''''''
100834100875 break;
100835100876 }
100836- case 18446744073709545468LLU: // 99999998d6'''''''''''''''
100877+ case 18446744073709545463LLU: // 99999998d1'''''''''''''''
100837100878 {
100838- state.addr = 18446744073709545471LLU; // 99999998d9'''''''''''''''
100879+ state.addr = 18446744073709545466LLU; // 99999998d4'''''''''''''''
100839100880 break;
100840100881 }
100841- case 18446744073709545471LLU: // 99999998d9'''''''''''''''
100882+ case 18446744073709545466LLU: // 99999998d4'''''''''''''''
100842100883 {
100843100884 heap.availilable_size_for_dynamic_objects += 0LLU;
100844100885 heap.availilable_size_for_dynamic_objects += 0LLU;
100845- state.addr = 18446744073709545467LLU; // 99999998d5'''''''''''''''
100886+ state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
100846100887 break;
100847100888 }
100848- case 18446744073709545474LLU: // 99999998eB'''''''''''''''
100889+ case 18446744073709545469LLU: // 99999998d7'''''''''''''''
100849100890 {
100850100891 fprintf(stderr, "%s", "re-definition of ");
100851100892 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
@@ -100854,35 +100895,35 @@
100854100895 fprintf(stderr, "%s\n", "");
100855100896 exit(-1);
100856100897 }
100857- state.addr = 18446744073709545467LLU; // 99999998d5'''''''''''''''
100898+ state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
100858100899 break;
100859100900 }
100860- case 18446744073709545467LLU: // 99999998d5'''''''''''''''
100901+ case 18446744073709545462LLU: // 99999998d0'''''''''''''''
100861100902 {
100862- state.addr = 18446744073709545478LLU; // 99999998eF'''''''''''''''
100903+ state.addr = 18446744073709545473LLU; // 99999998eA'''''''''''''''
100863100904 break;
100864100905 }
100865- case 18446744073709545478LLU: // 99999998eF'''''''''''''''
100906+ case 18446744073709545473LLU: // 99999998eA'''''''''''''''
100866100907 {
100867100908 // variable u64 match_____ goes out of scope
100868100909 // emitted destructur for type u64
100869100910 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference match_____ at 28
100870- state.addr = 18446744073709545480LLU; // 99999998eH'''''''''''''''
100911+ state.addr = 18446744073709545475LLU; // 99999998eC'''''''''''''''
100871100912 break;
100872100913 }
100873- case 18446744073709545480LLU: // 99999998eH'''''''''''''''
100914+ case 18446744073709545475LLU: // 99999998eC'''''''''''''''
100874100915 {
100875100916 // parameter-reference defidfn___ previous__ goes out of scope
100876100917 // parameter-reference list<defidfn___> fndefs____ goes out of scope
100877- state.addr = 18446744073709545483LLU; // 99999998eK'''''''''''''''
100918+ state.addr = 18446744073709545478LLU; // 99999998eF'''''''''''''''
100878100919 break;
100879100920 }
100880- case 18446744073709545482LLU: // 99999998eJ'''''''''''''''
100921+ case 18446744073709545477LLU: // 99999998eE'''''''''''''''
100881100922 {
100882- state.addr = !list_push_move(&heap, &/*current___*/*LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 13) ? 18446744073709545465LLU : 18446744073709545464LLU;
100923+ state.addr = !list_push_move(&heap, &/*current___*/*LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 13) ? 18446744073709545460LLU : 18446744073709545459LLU;
100883100924 break;
100884100925 }
100885- case 18446744073709545465LLU: // 99999998d3'''''''''''''''
100926+ case 18446744073709545460LLU: // 99999998dy'''''''''''''''
100886100927 {
100887100928 {
100888100929 uint64_t arg = *LOCAL_ACCESS(heap.data, 25LLU, 23LLU);
@@ -100903,7 +100944,7 @@
100903100944 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100904100945 }
100905100946 // ACCUMULATE ARGUMENTS - END
100906- uint64_t return_to = 18446744073709545463LLU;
100947+ uint64_t return_to = 18446744073709545458LLU;
100907100948 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100908100949 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100909100950 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100912,32 +100953,32 @@
100912100953 state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
100913100954 break;
100914100955 }
100915- case 18446744073709545463LLU: // 99999998d1'''''''''''''''
100956+ case 18446744073709545458LLU: // 99999998dw'''''''''''''''
100916100957 {
100917100958 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference current___ at 26
100918100959 heap.availilable_size_for_dynamic_objects += 0LLU;
100919100960 heap.availilable_size_for_dynamic_objects += 0LLU;
100920- state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
100961+ state.addr = 18446744073709545457LLU; // 99999998dv'''''''''''''''
100921100962 break;
100922100963 }
100923- case 18446744073709545464LLU: // 99999998d2'''''''''''''''
100964+ case 18446744073709545459LLU: // 99999998dx'''''''''''''''
100924100965 {
100925- state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545461LLU : 18446744073709545460LLU;
100966+ state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545456LLU : 18446744073709545455LLU;
100926100967 break;
100927100968 }
100928- case 18446744073709545461LLU: // 99999998dz'''''''''''''''
100969+ case 18446744073709545456LLU: // 99999998du'''''''''''''''
100929100970 {
100930100971 heap.availilable_size_for_dynamic_objects += 0LLU;
100931100972 heap.availilable_size_for_dynamic_objects += 0LLU;
100932- state.addr = 18446744073709545459LLU; // 99999998dx'''''''''''''''
100973+ state.addr = 18446744073709545454LLU; // 99999998ds'''''''''''''''
100933100974 break;
100934100975 }
100935- case 18446744073709545460LLU: // 99999998dy'''''''''''''''
100976+ case 18446744073709545455LLU: // 99999998dt'''''''''''''''
100936100977 {
100937- state.addr = /*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545458LLU : 18446744073709545457LLU;
100978+ state.addr = /*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545453LLU : 18446744073709545452LLU;
100938100979 break;
100939100980 }
100940- case 18446744073709545458LLU: // 99999998dw'''''''''''''''
100981+ case 18446744073709545453LLU: // 99999998dr'''''''''''''''
100941100982 {
100942100983 {
100943100984 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU))/*list*/, 13);
@@ -100951,7 +100992,7 @@
100951100992 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
100952100993 }
100953100994 // ACCUMULATE ARGUMENTS - END
100954- uint64_t return_to = 18446744073709545456LLU;
100995+ uint64_t return_to = 18446744073709545451LLU;
100955100996 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
100956100997 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
100957100998 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -100960,39 +101001,39 @@
100960101001 state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
100961101002 break;
100962101003 }
100963- case 18446744073709545456LLU: // 99999998du'''''''''''''''
101004+ case 18446744073709545451LLU: // 99999998dp'''''''''''''''
100964101005 {
100965101006 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dummy_____ at 26
100966101007 heap.availilable_size_for_dynamic_objects += 0LLU;
100967101008 heap.availilable_size_for_dynamic_objects += 0LLU;
100968- state.addr = 18446744073709545455LLU; // 99999998dt'''''''''''''''
101009+ state.addr = 18446744073709545450LLU; // 99999998do'''''''''''''''
100969101010 break;
100970101011 }
100971- case 18446744073709545457LLU: // 99999998dv'''''''''''''''
101012+ case 18446744073709545452LLU: // 99999998dq'''''''''''''''
100972101013 {
100973101014 {
100974101015 fprintf(stderr, "%s\n", "INTERNAL COMPILER ERROR in clumsy decl-replace-code: this should never happen!");
100975101016 exit(-1);
100976101017 }
100977- state.addr = 18446744073709545455LLU; // 99999998dt'''''''''''''''
101018+ state.addr = 18446744073709545450LLU; // 99999998do'''''''''''''''
100978101019 break;
100979101020 }
100980- case 18446744073709545455LLU: // 99999998dt'''''''''''''''
101021+ case 18446744073709545450LLU: // 99999998do'''''''''''''''
100981101022 {
100982- state.addr = 18446744073709545459LLU; // 99999998dx'''''''''''''''
101023+ state.addr = 18446744073709545454LLU; // 99999998ds'''''''''''''''
100983101024 break;
100984101025 }
100985- case 18446744073709545459LLU: // 99999998dx'''''''''''''''
101026+ case 18446744073709545454LLU: // 99999998ds'''''''''''''''
100986101027 {
100987- state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
101028+ state.addr = 18446744073709545457LLU; // 99999998dv'''''''''''''''
100988101029 break;
100989101030 }
100990- case 18446744073709545462LLU: // 99999998d0'''''''''''''''
101031+ case 18446744073709545457LLU: // 99999998dv'''''''''''''''
100991101032 {
100992- state.addr = 18446744073709545466LLU; // 99999998d4'''''''''''''''
101033+ state.addr = 18446744073709545461LLU; // 99999998dz'''''''''''''''
100993101034 break;
100994101035 }
100995- case 18446744073709545466LLU: // 99999998d4'''''''''''''''
101036+ case 18446744073709545461LLU: // 99999998dz'''''''''''''''
100996101037 {
100997101038 // variable u64 fresh_____ goes out of scope
100998101039 // emitted destructur for type u64
@@ -101000,15 +101041,15 @@
101000101041 // variable defidfn___ current___ goes out of scope
101001101042 // (uninitialized -> no destructor-call)
101002101043 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference current___ at 24
101003- state.addr = 18446744073709545486LLU; // 99999998eN'''''''''''''''
101044+ state.addr = 18446744073709545481LLU; // 99999998eI'''''''''''''''
101004101045 break;
101005101046 }
101006- case 18446744073709545486LLU: // 99999998eN'''''''''''''''
101047+ case 18446744073709545481LLU: // 99999998eI'''''''''''''''
101007101048 {
101008- state.addr = /*defined___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545453LLU : 18446744073709545452LLU;
101049+ state.addr = /*defined___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545448LLU : 18446744073709545447LLU;
101009101050 break;
101010101051 }
101011- case 18446744073709545453LLU: // 99999998dr'''''''''''''''
101052+ case 18446744073709545448LLU: // 99999998dm'''''''''''''''
101012101053 {
101013101054 list_reverse(heap.data, &/*results___*/*LOCAL_ACCESS(heap.data, 23LLU, 17LLU));
101014101055 {
@@ -101025,15 +101066,15 @@
101025101066 uint64_t arg = 0LLU;
101026101067 LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
101027101068 }
101028- state.addr = 18446744073709545451LLU; // 99999998dp'''''''''''''''
101069+ state.addr = 18446744073709545446LLU; // 99999998dk'''''''''''''''
101029101070 break;
101030101071 }
101031- case 18446744073709545451LLU: // 99999998dp'''''''''''''''
101072+ case 18446744073709545446LLU: // 99999998dk'''''''''''''''
101032101073 {
101033101074 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)) = (uint64_t)getchar();
101034101075 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)) > 255)
101035101076 {
101036- state.addr = 18446744073709545450LLU; // 99999998do'''''''''''''''
101077+ state.addr = 18446744073709545445LLU; // 99999998dj'''''''''''''''
101037101078 break;
101038101079 }
101039101080 // ACCUMULATE ARGUMENTS - BEGIN
@@ -101042,7 +101083,7 @@
101042101083 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101043101084 }
101044101085 // ACCUMULATE ARGUMENTS - END
101045- uint64_t return_to = 18446744073709545447LLU;
101086+ uint64_t return_to = 18446744073709545442LLU;
101046101087 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101047101088 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101048101089 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101051,12 +101092,12 @@
101051101092 state.addr = 839519719621918720LLU; // skipws____
101052101093 break;
101053101094 }
101054- case 18446744073709545447LLU: // 99999998dl'''''''''''''''
101095+ case 18446744073709545442LLU: // 99999998dg'''''''''''''''
101055101096 {
101056- state.addr = 18446744073709545448LLU; // 99999998dm'''''''''''''''
101097+ state.addr = 18446744073709545443LLU; // 99999998dh'''''''''''''''
101057101098 break;
101058101099 }
101059- case 18446744073709545448LLU: // 99999998dm'''''''''''''''
101100+ case 18446744073709545443LLU: // 99999998dh'''''''''''''''
101060101101 {
101061101102 {
101062101103 uint64_t arg = 0LLU;
@@ -101064,10 +101105,10 @@
101064101105 }
101065101106 /*repeatid__*/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 26LLU, 5LLU)));
101066101107 /*matchsym__*/*LOCAL_ACCESS(heap.data, 26LLU, 20LLU) = /*repeatid__*/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) != /*def_id____*/*LOCAL_ACCESS(heap.data, 26LLU, 7LLU);
101067- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 26LLU, 20LLU) ? 18446744073709545446LLU : 18446744073709545445LLU;
101108+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 26LLU, 20LLU) ? 18446744073709545441LLU : 18446744073709545440LLU;
101068101109 break;
101069101110 }
101070- case 18446744073709545446LLU: // 99999998dk'''''''''''''''
101111+ case 18446744073709545441LLU: // 99999998df'''''''''''''''
101071101112 {
101072101113 // ACCUMULATE ARGUMENTS - BEGIN
101073101114 {
@@ -101075,7 +101116,7 @@
101075101116 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101076101117 }
101077101118 // ACCUMULATE ARGUMENTS - END
101078- uint64_t return_to = 18446744073709545443LLU;
101119+ uint64_t return_to = 18446744073709545438LLU;
101079101120 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101080101121 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101081101122 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101084,12 +101125,12 @@
101084101125 state.addr = 819847183515949359LLU; // reportinit
101085101126 break;
101086101127 }
101087- case 18446744073709545443LLU: // 99999998dh'''''''''''''''
101128+ case 18446744073709545438LLU: // 99999998dc'''''''''''''''
101088101129 {
101089- state.addr = 18446744073709545444LLU; // 99999998di'''''''''''''''
101130+ state.addr = 18446744073709545439LLU; // 99999998dd'''''''''''''''
101090101131 break;
101091101132 }
101092- case 18446744073709545444LLU: // 99999998di'''''''''''''''
101133+ case 18446744073709545439LLU: // 99999998dd'''''''''''''''
101093101134 {
101094101135 fprintf(stderr, "%s", "pattern-matching definition-case must have same name as declaration - expected ");
101095101136 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 26LLU, 7LLU));
@@ -101099,18 +101140,18 @@
101099101140 fprintf(stderr, "%s\n", "");
101100101141 exit(-1);
101101101142 }
101102- state.addr = 18446744073709545445LLU; // 99999998dj'''''''''''''''
101143+ state.addr = 18446744073709545440LLU; // 99999998de'''''''''''''''
101103101144 break;
101104101145 }
101105- case 18446744073709545445LLU: // 99999998dj'''''''''''''''
101146+ case 18446744073709545440LLU: // 99999998de'''''''''''''''
101106101147 {
101107101148 // variable u64 repeatid__ goes out of scope
101108101149 // emitted destructur for type u64
101109101150 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference repeatid__ at 26
101110- state.addr = 18446744073709545449LLU; // 99999998dn'''''''''''''''
101151+ state.addr = 18446744073709545444LLU; // 99999998di'''''''''''''''
101111101152 break;
101112101153 }
101113- case 18446744073709545449LLU: // 99999998dn'''''''''''''''
101154+ case 18446744073709545444LLU: // 99999998di'''''''''''''''
101114101155 {
101115101156 {
101116101157 uint64_t arg = 1LLU;
@@ -101206,7 +101247,7 @@
101206101247 LOCAL_PUSH_MOVE(&heap, 20LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101207101248 }
101208101249 // ACCUMULATE ARGUMENTS - END
101209- uint64_t return_to = 18446744073709545441LLU;
101250+ uint64_t return_to = 18446744073709545436LLU;
101210101251 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/*address of closure-in-construction*/, 0));
101211101252 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101212101253 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101215,22 +101256,22 @@
101215101256 state.addr = 288592327072833536LLU; // PARSEDEF__
101216101257 break;
101217101258 }
101218- case 18446744073709545441LLU: // 99999998df'''''''''''''''
101259+ case 18446744073709545436LLU: // 99999998da'''''''''''''''
101219101260 {
101220- state.addr = 18446744073709545442LLU; // 99999998dg'''''''''''''''
101261+ state.addr = 18446744073709545437LLU; // 99999998db'''''''''''''''
101221101262 break;
101222101263 }
101223- case 18446744073709545442LLU: // 99999998dg'''''''''''''''
101264+ case 18446744073709545437LLU: // 99999998db'''''''''''''''
101224101265 {
101225- state.addr = /*carryflag_*/*LOCAL_ACCESS(heap.data, 27LLU, 25LLU) ? 18446744073709545440LLU : 18446744073709545439LLU;
101266+ state.addr = /*carryflag_*/*LOCAL_ACCESS(heap.data, 27LLU, 25LLU) ? 18446744073709545435LLU : 18446744073709545434LLU;
101226101267 break;
101227101268 }
101228- case 18446744073709545440LLU: // 99999998de'''''''''''''''
101269+ case 18446744073709545435LLU: // 99999998d$'''''''''''''''
101229101270 {
101230- state.addr = /*mustorder_*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545438LLU : 18446744073709545437LLU;
101271+ state.addr = /*mustorder_*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545433LLU : 18446744073709545432LLU;
101231101272 break;
101232101273 }
101233- case 18446744073709545438LLU: // 99999998dc'''''''''''''''
101274+ case 18446744073709545433LLU: // 99999998dY'''''''''''''''
101234101275 {
101235101276 *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = 1LLU;
101236101277
@@ -101240,7 +101281,7 @@
101240101281 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101241101282 }
101242101283 // ACCUMULATE ARGUMENTS - END
101243- uint64_t return_to = 18446744073709545435LLU;
101284+ uint64_t return_to = 18446744073709545430LLU;
101244101285 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101245101286 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101246101287 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101249,12 +101290,12 @@
101249101290 state.addr = 587881345921715008LLU; // emitenter_
101250101291 break;
101251101292 }
101252- case 18446744073709545435LLU: // 99999998d$'''''''''''''''
101293+ case 18446744073709545430LLU: // 99999998dV'''''''''''''''
101253101294 {
101254- state.addr = 18446744073709545436LLU; // 99999998da'''''''''''''''
101295+ state.addr = 18446744073709545431LLU; // 99999998dW'''''''''''''''
101255101296 break;
101256101297 }
101257- case 18446744073709545436LLU: // 99999998da'''''''''''''''
101298+ case 18446744073709545431LLU: // 99999998dW'''''''''''''''
101258101299 {
101259101300 fprintf(stdout, "%s", "\n fprintf(stderr, \"INTERNAL COMPILER ERROR: missing pattern-match-case in definition of ");
101260101301 printid(stdout, /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 7LLU));
@@ -101270,7 +101311,7 @@
101270101311 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101271101312 }
101272101313 // ACCUMULATE ARGUMENTS - END
101273- uint64_t return_to = 18446744073709545432LLU;
101314+ uint64_t return_to = 18446744073709545427LLU;
101274101315 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101275101316 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101276101317 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101279,52 +101320,52 @@
101279101320 state.addr = 587881351406074923LLU; // emitjumpup
101280101321 break;
101281101322 }
101282- case 18446744073709545432LLU: // 99999998dX'''''''''''''''
101323+ case 18446744073709545427LLU: // 99999998dS'''''''''''''''
101283101324 {
101284- state.addr = 18446744073709545433LLU; // 99999998dY'''''''''''''''
101325+ state.addr = 18446744073709545428LLU; // 99999998dT'''''''''''''''
101285101326 break;
101286101327 }
101287- case 18446744073709545433LLU: // 99999998dY'''''''''''''''
101328+ case 18446744073709545428LLU: // 99999998dT'''''''''''''''
101288101329 {
101289101330 // variable u64 level_____ goes out of scope
101290101331 // emitted destructur for type u64
101291101332 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 28
101292- state.addr = 18446744073709545434LLU; // 99999998dZ'''''''''''''''
101333+ state.addr = 18446744073709545429LLU; // 99999998dU'''''''''''''''
101293101334 break;
101294101335 }
101295- case 18446744073709545434LLU: // 99999998dZ'''''''''''''''
101336+ case 18446744073709545429LLU: // 99999998dU'''''''''''''''
101296101337 {
101297- state.addr = 18446744073709545437LLU; // 99999998db'''''''''''''''
101338+ state.addr = 18446744073709545432LLU; // 99999998dX'''''''''''''''
101298101339 break;
101299101340 }
101300- case 18446744073709545437LLU: // 99999998db'''''''''''''''
101341+ case 18446744073709545432LLU: // 99999998dX'''''''''''''''
101301101342 {
101302101343 heap.availilable_size_for_dynamic_objects += 0LLU;
101303101344 heap.availilable_size_for_dynamic_objects += 0LLU;
101304- state.addr = 18446744073709545431LLU; // 99999998dW'''''''''''''''
101345+ state.addr = 18446744073709545426LLU; // 99999998dR'''''''''''''''
101305101346 break;
101306101347 }
101307- case 18446744073709545439LLU: // 99999998dd'''''''''''''''
101348+ case 18446744073709545434LLU: // 99999998dZ'''''''''''''''
101308101349 {
101309101350 *LOCAL_ACCESS(heap.data, 27LLU, 25LLU) = 1LLU;
101310101351
101311- state.addr = 18446744073709545431LLU; // 99999998dW'''''''''''''''
101352+ state.addr = 18446744073709545426LLU; // 99999998dR'''''''''''''''
101312101353 break;
101313101354 }
101314- case 18446744073709545431LLU: // 99999998dW'''''''''''''''
101355+ case 18446744073709545426LLU: // 99999998dR'''''''''''''''
101315101356 {
101316- state.addr = /*concluding*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709545430LLU : 18446744073709545429LLU;
101357+ state.addr = /*concluding*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709545425LLU : 18446744073709545424LLU;
101317101358 break;
101318101359 }
101319- case 18446744073709545430LLU: // 99999998dV'''''''''''''''
101360+ case 18446744073709545425LLU: // 99999998dQ'''''''''''''''
101320101361 {
101321101362 ungetc(0, stdin);
101322101363 heap.availilable_size_for_dynamic_objects += 0LLU;
101323101364 heap.availilable_size_for_dynamic_objects += 0LLU;
101324- state.addr = 18446744073709545428LLU; // 99999998dT'''''''''''''''
101365+ state.addr = 18446744073709545423LLU; // 99999998dO'''''''''''''''
101325101366 break;
101326101367 }
101327- case 18446744073709545429LLU: // 99999998dU'''''''''''''''
101368+ case 18446744073709545424LLU: // 99999998dP'''''''''''''''
101328101369 {
101329101370 /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 27LLU, 5LLU)) = (uint64_t)getchar();
101330101371 // ACCUMULATE ARGUMENTS - BEGIN
@@ -101333,7 +101374,7 @@
101333101374 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101334101375 }
101335101376 // ACCUMULATE ARGUMENTS - END
101336- uint64_t return_to = 18446744073709545426LLU;
101377+ uint64_t return_to = 18446744073709545421LLU;
101337101378 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101338101379 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101339101380 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101342,12 +101383,12 @@
101342101383 state.addr = 839519719621918720LLU; // skipws____
101343101384 break;
101344101385 }
101345- case 18446744073709545426LLU: // 99999998dR'''''''''''''''
101386+ case 18446744073709545421LLU: // 99999998dM'''''''''''''''
101346101387 {
101347- state.addr = 18446744073709545427LLU; // 99999998dS'''''''''''''''
101388+ state.addr = 18446744073709545422LLU; // 99999998dN'''''''''''''''
101348101389 break;
101349101390 }
101350- case 18446744073709545427LLU: // 99999998dS'''''''''''''''
101391+ case 18446744073709545422LLU: // 99999998dN'''''''''''''''
101351101392 {
101352101393 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 27LLU, 5LLU)), stdin);
101353101394 if('|' != (char)getchar())
@@ -101355,10 +101396,10 @@
101355101396 fprintf(stderr, "match failed at char %c\n", (char)124LLU);
101356101397 exit(-1);
101357101398 }
101358- state.addr = 18446744073709545428LLU; // 99999998dT'''''''''''''''
101399+ state.addr = 18446744073709545423LLU; // 99999998dO'''''''''''''''
101359101400 break;
101360101401 }
101361- case 18446744073709545428LLU: // 99999998dT'''''''''''''''
101402+ case 18446744073709545423LLU: // 99999998dO'''''''''''''''
101362101403 {
101363101404 // variable u64 concluding goes out of scope
101364101405 // emitted destructur for type u64
@@ -101366,10 +101407,10 @@
101366101407 // variable u64 carryflag_ goes out of scope
101367101408 // emitted destructur for type u64
101368101409 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference carryflag_ at 26
101369- state.addr = 18446744073709545451LLU; // 99999998dp'''''''''''''''
101410+ state.addr = 18446744073709545446LLU; // 99999998dk'''''''''''''''
101370101411 break;
101371101412 }
101372- case 18446744073709545450LLU: // 99999998do'''''''''''''''
101413+ case 18446744073709545445LLU: // 99999998dj'''''''''''''''
101373101414 {
101374101415 /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)) = (uint64_t)getchar();
101375101416 // variable u64 mustorder_ goes out of scope
@@ -101378,15 +101419,15 @@
101378101419 // variable u64 caseaddr__ goes out of scope
101379101420 // emitted destructur for type u64
101380101421 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference caseaddr__ at 24
101381- state.addr = 18446744073709545452LLU; // 99999998dq'''''''''''''''
101422+ state.addr = 18446744073709545447LLU; // 99999998dl'''''''''''''''
101382101423 break;
101383101424 }
101384- case 18446744073709545452LLU: // 99999998dq'''''''''''''''
101425+ case 18446744073709545447LLU: // 99999998dl'''''''''''''''
101385101426 {
101386- state.addr = 18446744073709545454LLU; // 99999998ds'''''''''''''''
101427+ state.addr = 18446744073709545449LLU; // 99999998dn'''''''''''''''
101387101428 break;
101388101429 }
101389- case 18446744073709545454LLU: // 99999998ds'''''''''''''''
101430+ case 18446744073709545449LLU: // 99999998dn'''''''''''''''
101390101431 {
101391101432 // variable u64 defined___ goes out of scope
101392101433 // emitted destructur for type u64
@@ -101393,14 +101434,14 @@
101393101434 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defined___ at 23
101394101435 // variable list<signdef___> signs_____ goes out of scope
101395101436 // emitted destructur for type list<signdef___>
101396- state.addr = 18446744073709545424LLU; // 99999998dP'''''''''''''''
101437+ state.addr = 18446744073709545419LLU; // 99999998dK'''''''''''''''
101397101438 break;
101398101439 }
101399- case 18446744073709545424LLU: // 99999998dP'''''''''''''''
101440+ case 18446744073709545419LLU: // 99999998dK'''''''''''''''
101400101441 {
101401101442 if(!*LOCAL_ACCESS(heap.data, 22LLU, 21LLU)/*list*/)
101402101443 {
101403- state.addr = 18446744073709545425LLU; // 99999998dQ'''''''''''''''
101444+ state.addr = 18446744073709545420LLU; // 99999998dL'''''''''''''''
101404101445 break;
101405101446 }
101406101447 // temporary list-element
@@ -101414,7 +101455,7 @@
101414101455 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101415101456 }
101416101457 // ACCUMULATE ARGUMENTS - END
101417- uint64_t return_to = 18446744073709545423LLU;
101458+ uint64_t return_to = 18446744073709545418LLU;
101418101459 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101419101460 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101420101461 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101423,22 +101464,22 @@
101423101464 state.addr = 18446744073709551435LLU; // 999999997K'''''''''''''''
101424101465 break;
101425101466 }
101426- case 18446744073709545423LLU: // 99999998dO'''''''''''''''
101467+ case 18446744073709545418LLU: // 99999998dJ'''''''''''''''
101427101468 {
101428101469 // RELEASE temporary destructor-variable
101429101470 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
101430- state.addr = 18446744073709545424LLU; // 99999998dP'''''''''''''''
101471+ state.addr = 18446744073709545419LLU; // 99999998dK'''''''''''''''
101431101472 break;
101432101473 }
101433- case 18446744073709545425LLU: // 99999998dQ'''''''''''''''
101474+ case 18446744073709545420LLU: // 99999998dL'''''''''''''''
101434101475 {
101435101476 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference signs_____ at 22
101436101477 heap.availilable_size_for_dynamic_objects += 0LLU;
101437101478 heap.availilable_size_for_dynamic_objects += 0LLU;
101438- state.addr = 18446744073709545422LLU; // 99999998dN'''''''''''''''
101479+ state.addr = 18446744073709545417LLU; // 99999998dI'''''''''''''''
101439101480 break;
101440101481 }
101441- case 18446744073709545531LLU: // 99999998e5'''''''''''''''
101482+ case 18446744073709545526LLU: // 99999998e0'''''''''''''''
101442101483 {
101443101484 {
101444101485 uint64_t arg = 0LLU;
@@ -101479,7 +101520,7 @@
101479101520 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101480101521 }
101481101522 // ACCUMULATE ARGUMENTS - END
101482- uint64_t return_to = 18446744073709545419LLU;
101523+ uint64_t return_to = 18446744073709545414LLU;
101483101524 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
101484101525 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101485101526 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101488,12 +101529,12 @@
101488101529 state.addr = 782701543533239168LLU; // parsepars_
101489101530 break;
101490101531 }
101491- case 18446744073709545419LLU: // 99999998dK'''''''''''''''
101532+ case 18446744073709545414LLU: // 99999998dF'''''''''''''''
101492101533 {
101493- state.addr = 18446744073709545420LLU; // 99999998dL'''''''''''''''
101534+ state.addr = 18446744073709545415LLU; // 99999998dG'''''''''''''''
101494101535 break;
101495101536 }
101496- case 18446744073709545420LLU: // 99999998dL'''''''''''''''
101537+ case 18446744073709545415LLU: // 99999998dG'''''''''''''''
101497101538 {
101498101539 {
101499101540 uint64_t arg = 0LLU;
@@ -101504,10 +101545,10 @@
101504101545 // variable u64 argscount_ goes out of scope
101505101546 // emitted destructur for type u64
101506101547 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference argscount_ at 25
101507- state.addr = 18446744073709545418LLU; // 99999998dJ'''''''''''''''
101548+ state.addr = 18446744073709545413LLU; // 99999998dE'''''''''''''''
101508101549 break;
101509101550 }
101510- case 18446744073709545418LLU: // 99999998dJ'''''''''''''''
101551+ case 18446744073709545413LLU: // 99999998dE'''''''''''''''
101511101552 {
101512101553 // ACCUMULATE ARGUMENTS - BEGIN
101513101554 {
@@ -101515,7 +101556,7 @@
101515101556 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101516101557 }
101517101558 // ACCUMULATE ARGUMENTS - END
101518- uint64_t return_to = 18446744073709545416LLU;
101559+ uint64_t return_to = 18446744073709545411LLU;
101519101560 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101520101561 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101521101562 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101524,12 +101565,12 @@
101524101565 state.addr = 839519719621918720LLU; // skipws____
101525101566 break;
101526101567 }
101527- case 18446744073709545416LLU: // 99999998dH'''''''''''''''
101568+ case 18446744073709545411LLU: // 99999998dC'''''''''''''''
101528101569 {
101529- state.addr = 18446744073709545417LLU; // 99999998dI'''''''''''''''
101570+ state.addr = 18446744073709545412LLU; // 99999998dD'''''''''''''''
101530101571 break;
101531101572 }
101532- case 18446744073709545417LLU: // 99999998dI'''''''''''''''
101573+ case 18446744073709545412LLU: // 99999998dD'''''''''''''''
101533101574 {
101534101575 /*defbodysz_*/*LOCAL_ACCESS(heap.data, 24LLU, 14LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 24LLU, 5LLU)));
101535101576 *LOCAL_ACCESS(heap.data, 24LLU, 15LLU) = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 24LLU, 14LLU);
@@ -101540,7 +101581,7 @@
101540101581 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101541101582 }
101542101583 // ACCUMULATE ARGUMENTS - END
101543- uint64_t return_to = 18446744073709545414LLU;
101584+ uint64_t return_to = 18446744073709545409LLU;
101544101585 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101545101586 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101546101587 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101549,12 +101590,12 @@
101549101590 state.addr = 839519719621918720LLU; // skipws____
101550101591 break;
101551101592 }
101552- case 18446744073709545414LLU: // 99999998dF'''''''''''''''
101593+ case 18446744073709545409LLU: // 99999998dA'''''''''''''''
101553101594 {
101554- state.addr = 18446744073709545415LLU; // 99999998dG'''''''''''''''
101595+ state.addr = 18446744073709545410LLU; // 99999998dB'''''''''''''''
101555101596 break;
101556101597 }
101557- case 18446744073709545415LLU: // 99999998dG'''''''''''''''
101598+ case 18446744073709545410LLU: // 99999998dB'''''''''''''''
101558101599 {
101559101600 /*remainheap*/*LOCAL_ACCESS(heap.data, 24LLU, 16LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 24LLU, 5LLU)));
101560101601 list_reverse(heap.data, &/*results___*/*LOCAL_ACCESS(heap.data, 24LLU, 17LLU));
@@ -101561,10 +101602,10 @@
101561101602 // variable u64 returnbase goes out of scope
101562101603 // emitted destructur for type u64
101563101604 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference returnbase at 24
101564- state.addr = 18446744073709545421LLU; // 99999998dM'''''''''''''''
101605+ state.addr = 18446744073709545416LLU; // 99999998dH'''''''''''''''
101565101606 break;
101566101607 }
101567- case 18446744073709545421LLU: // 99999998dM'''''''''''''''
101608+ case 18446744073709545416LLU: // 99999998dH'''''''''''''''
101568101609 {
101569101610 *LOCAL_ACCESS(heap.data, 23LLU, 19LLU) = 59LLU;
101570101611
@@ -101576,7 +101617,7 @@
101576101617 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101577101618 }
101578101619 // ACCUMULATE ARGUMENTS - END
101579- uint64_t return_to = 18446744073709545411LLU;
101620+ uint64_t return_to = 18446744073709545406LLU;
101580101621 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101581101622 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101582101623 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101585,12 +101626,12 @@
101585101626 state.addr = 839519719621918720LLU; // skipws____
101586101627 break;
101587101628 }
101588- case 18446744073709545411LLU: // 99999998dC'''''''''''''''
101629+ case 18446744073709545406LLU: // 99999998c8'''''''''''''''
101589101630 {
101590- state.addr = 18446744073709545412LLU; // 99999998dD'''''''''''''''
101631+ state.addr = 18446744073709545407LLU; // 99999998c9'''''''''''''''
101591101632 break;
101592101633 }
101593- case 18446744073709545412LLU: // 99999998dD'''''''''''''''
101634+ case 18446744073709545407LLU: // 99999998c9'''''''''''''''
101594101635 {
101595101636 // ACCUMULATE ARGUMENTS - BEGIN
101596101637 {
@@ -101606,7 +101647,7 @@
101606101647 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101607101648 }
101608101649 // ACCUMULATE ARGUMENTS - END
101609- uint64_t return_to = 18446744073709545409LLU;
101650+ uint64_t return_to = 18446744073709545404LLU;
101610101651 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
101611101652 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101612101653 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101615,38 +101656,38 @@
101615101656 state.addr = 728666047794575267LLU; // matchoptch
101616101657 break;
101617101658 }
101618- case 18446744073709545409LLU: // 99999998dA'''''''''''''''
101659+ case 18446744073709545404LLU: // 99999998c6'''''''''''''''
101619101660 {
101620- state.addr = 18446744073709545410LLU; // 99999998dB'''''''''''''''
101661+ state.addr = 18446744073709545405LLU; // 99999998c7'''''''''''''''
101621101662 break;
101622101663 }
101623- case 18446744073709545410LLU: // 99999998dB'''''''''''''''
101664+ case 18446744073709545405LLU: // 99999998c7'''''''''''''''
101624101665 {
101625- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545408LLU : 18446744073709545407LLU;
101666+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545403LLU : 18446744073709545402LLU;
101626101667 break;
101627101668 }
101628- case 18446744073709545408LLU: // 99999998d_'''''''''''''''
101669+ case 18446744073709545403LLU: // 99999998c5'''''''''''''''
101629101670 {
101630101671 *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0LLU;
101631101672
101632101673 heap.availilable_size_for_dynamic_objects += 0LLU;
101633101674 heap.availilable_size_for_dynamic_objects += 0LLU;
101634- state.addr = 18446744073709545406LLU; // 99999998c8'''''''''''''''
101675+ state.addr = 18446744073709545401LLU; // 99999998c3'''''''''''''''
101635101676 break;
101636101677 }
101637- case 18446744073709545407LLU: // 99999998c9'''''''''''''''
101678+ case 18446744073709545402LLU: // 99999998c4'''''''''''''''
101638101679 {
101639101680 *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 1LLU;
101640101681
101641- state.addr = 18446744073709545406LLU; // 99999998c8'''''''''''''''
101682+ state.addr = 18446744073709545401LLU; // 99999998c3'''''''''''''''
101642101683 break;
101643101684 }
101644- case 18446744073709545406LLU: // 99999998c8'''''''''''''''
101685+ case 18446744073709545401LLU: // 99999998c3'''''''''''''''
101645101686 {
101646- state.addr = 18446744073709545413LLU; // 99999998dE'''''''''''''''
101687+ state.addr = 18446744073709545408LLU; // 99999998d_'''''''''''''''
101647101688 break;
101648101689 }
101649- case 18446744073709545413LLU: // 99999998dE'''''''''''''''
101690+ case 18446744073709545408LLU: // 99999998d_'''''''''''''''
101650101691 {
101651101692 {
101652101693 uint64_t arg = 0LLU;
@@ -101694,7 +101735,7 @@
101694101735 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101695101736 }
101696101737 // ACCUMULATE ARGUMENTS - END
101697- uint64_t return_to = 18446744073709545403LLU;
101738+ uint64_t return_to = 18446744073709545398LLU;
101698101739 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0));
101699101740 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101700101741 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101703,12 +101744,12 @@
101703101744 state.addr = 728626598349373440LLU; // makedef___
101704101745 break;
101705101746 }
101706- case 18446744073709545403LLU: // 99999998c5'''''''''''''''
101747+ case 18446744073709545398LLU: // 99999998c0'''''''''''''''
101707101748 {
101708- state.addr = 18446744073709545404LLU; // 99999998c6'''''''''''''''
101749+ state.addr = 18446744073709545399LLU; // 99999998c1'''''''''''''''
101709101750 break;
101710101751 }
101711- case 18446744073709545404LLU: // 99999998c6'''''''''''''''
101752+ case 18446744073709545399LLU: // 99999998c1'''''''''''''''
101712101753 {
101713101754 {
101714101755 uint64_t arg = 1LLU;
@@ -101722,10 +101763,10 @@
101722101763 uint64_t arg = 0;
101723101764 LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg);
101724101765 }
101725- state.addr = 18446744073709545402LLU; // 99999998c4'''''''''''''''
101766+ state.addr = 18446744073709545397LLU; // 99999998cz'''''''''''''''
101726101767 break;
101727101768 }
101728- case 18446744073709545402LLU: // 99999998c4'''''''''''''''
101769+ case 18446744073709545397LLU: // 99999998cz'''''''''''''''
101729101770 {
101730101771 if(!*LOCAL_ACCESS(heap.data, 27LLU, 25LLU))
101731101772 {
@@ -101732,16 +101773,16 @@
101732101773 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 27
101733101774 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 26
101734101775 {
101735- state.addr = 18446744073709545401LLU; // 99999998c3'''''''''''''''
101776+ state.addr = 18446744073709545396LLU; // 99999998cy'''''''''''''''
101736101777 break;
101737101778 }
101738101779 }
101739101780 /*direct*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = (*LOCAL_ACCESS(heap.data, 27LLU, 25LLU) << 1) + 1LLU;
101740101781 *LOCAL_ACCESS(heap.data, 27LLU, 25LLU) = heap.data[*LOCAL_ACCESS(heap.data, 27LLU, 25LLU)].elem0;
101741- state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545400LLU : 18446744073709545399LLU;
101782+ state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545395LLU : 18446744073709545394LLU;
101742101783 break;
101743101784 }
101744- case 18446744073709545400LLU: // 99999998c2'''''''''''''''
101785+ case 18446744073709545395LLU: // 99999998cx'''''''''''''''
101745101786 {
101746101787 {
101747101788 uint64_t arg = 0LLU;
@@ -101748,10 +101789,10 @@
101748101789 LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
101749101790 }
101750101791 /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU) == /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 0LLU));
101751- state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545398LLU : 18446744073709545397LLU;
101792+ state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545393LLU : 18446744073709545392LLU;
101752101793 break;
101753101794 }
101754- case 18446744073709545398LLU: // 99999998c0'''''''''''''''
101795+ case 18446744073709545393LLU: // 99999998cv'''''''''''''''
101755101796 {
101756101797 *LOCAL_ACCESS(heap.data, 28LLU, 24LLU) = 0LLU;
101757101798
@@ -101769,7 +101810,7 @@
101769101810 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101770101811 }
101771101812 // ACCUMULATE ARGUMENTS - END
101772- uint64_t return_to = 18446744073709545395LLU;
101813+ uint64_t return_to = 18446744073709545390LLU;
101773101814 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
101774101815 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101775101816 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101778,22 +101819,22 @@
101778101819 state.addr = 589059069805989888LLU; // equfndef__
101779101820 break;
101780101821 }
101781- case 18446744073709545395LLU: // 99999998cx'''''''''''''''
101822+ case 18446744073709545390LLU: // 99999998cs'''''''''''''''
101782101823 {
101783- state.addr = 18446744073709545396LLU; // 99999998cy'''''''''''''''
101824+ state.addr = 18446744073709545391LLU; // 99999998ct'''''''''''''''
101784101825 break;
101785101826 }
101786- case 18446744073709545396LLU: // 99999998cy'''''''''''''''
101827+ case 18446744073709545391LLU: // 99999998ct'''''''''''''''
101787101828 {
101788- state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545394LLU : 18446744073709545393LLU;
101829+ state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545389LLU : 18446744073709545388LLU;
101789101830 break;
101790101831 }
101791- case 18446744073709545394LLU: // 99999998cw'''''''''''''''
101832+ case 18446744073709545389LLU: // 99999998cr'''''''''''''''
101792101833 {
101793- state.addr = /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545392LLU : 18446744073709545391LLU;
101834+ state.addr = /*previous__*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545387LLU : 18446744073709545386LLU;
101794101835 break;
101795101836 }
101796- case 18446744073709545392LLU: // 99999998cu'''''''''''''''
101837+ case 18446744073709545387LLU: // 99999998cp'''''''''''''''
101797101838 {
101798101839 fprintf(stderr, "%s", "re-definition of ");
101799101840 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
@@ -101803,42 +101844,42 @@
101803101844 }
101804101845 heap.availilable_size_for_dynamic_objects += 0LLU;
101805101846 heap.availilable_size_for_dynamic_objects += 0LLU;
101806- state.addr = 18446744073709545390LLU; // 99999998cs'''''''''''''''
101847+ state.addr = 18446744073709545385LLU; // 99999998cn'''''''''''''''
101807101848 break;
101808101849 }
101809- case 18446744073709545391LLU: // 99999998ct'''''''''''''''
101850+ case 18446744073709545386LLU: // 99999998co'''''''''''''''
101810101851 {
101811- state.addr = /*current___*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545389LLU : 18446744073709545388LLU;
101852+ state.addr = /*current___*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545384LLU : 18446744073709545383LLU;
101812101853 break;
101813101854 }
101814- case 18446744073709545389LLU: // 99999998cr'''''''''''''''
101855+ case 18446744073709545384LLU: // 99999998cm'''''''''''''''
101815101856 {
101816101857 swap(&/*current___*/*LOCAL_ACCESS(heap.data, 28LLU, 23LLU), &/*previous__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU)));
101817101858 heap.availilable_size_for_dynamic_objects += 0LLU;
101818101859 heap.availilable_size_for_dynamic_objects += 0LLU;
101819- state.addr = 18446744073709545387LLU; // 99999998cp'''''''''''''''
101860+ state.addr = 18446744073709545382LLU; // 99999998ck'''''''''''''''
101820101861 break;
101821101862 }
101822- case 18446744073709545388LLU: // 99999998cq'''''''''''''''
101863+ case 18446744073709545383LLU: // 99999998cl'''''''''''''''
101823101864 {
101824101865 fprintf(stderr, "%s", "WARNING: superfluous re-declaration of ");
101825101866 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
101826- state.addr = 18446744073709545387LLU; // 99999998cp'''''''''''''''
101867+ state.addr = 18446744073709545382LLU; // 99999998ck'''''''''''''''
101827101868 break;
101828101869 }
101829- case 18446744073709545387LLU: // 99999998cp'''''''''''''''
101870+ case 18446744073709545382LLU: // 99999998ck'''''''''''''''
101830101871 {
101831- state.addr = 18446744073709545390LLU; // 99999998cs'''''''''''''''
101872+ state.addr = 18446744073709545385LLU; // 99999998cn'''''''''''''''
101832101873 break;
101833101874 }
101834- case 18446744073709545390LLU: // 99999998cs'''''''''''''''
101875+ case 18446744073709545385LLU: // 99999998cn'''''''''''''''
101835101876 {
101836101877 heap.availilable_size_for_dynamic_objects += 0LLU;
101837101878 heap.availilable_size_for_dynamic_objects += 0LLU;
101838- state.addr = 18446744073709545386LLU; // 99999998co'''''''''''''''
101879+ state.addr = 18446744073709545381LLU; // 99999998cj'''''''''''''''
101839101880 break;
101840101881 }
101841- case 18446744073709545393LLU: // 99999998cv'''''''''''''''
101882+ case 18446744073709545388LLU: // 99999998cq'''''''''''''''
101842101883 {
101843101884 fprintf(stderr, "%s", "re-definition of ");
101844101885 printid(stderr, /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
@@ -101847,35 +101888,35 @@
101847101888 fprintf(stderr, "%s\n", "");
101848101889 exit(-1);
101849101890 }
101850- state.addr = 18446744073709545386LLU; // 99999998co'''''''''''''''
101891+ state.addr = 18446744073709545381LLU; // 99999998cj'''''''''''''''
101851101892 break;
101852101893 }
101853- case 18446744073709545386LLU: // 99999998co'''''''''''''''
101894+ case 18446744073709545381LLU: // 99999998cj'''''''''''''''
101854101895 {
101855- state.addr = 18446744073709545397LLU; // 99999998cz'''''''''''''''
101896+ state.addr = 18446744073709545392LLU; // 99999998cu'''''''''''''''
101856101897 break;
101857101898 }
101858- case 18446744073709545397LLU: // 99999998cz'''''''''''''''
101899+ case 18446744073709545392LLU: // 99999998cu'''''''''''''''
101859101900 {
101860101901 // variable u64 match_____ goes out of scope
101861101902 // emitted destructur for type u64
101862101903 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference match_____ at 28
101863- state.addr = 18446744073709545399LLU; // 99999998c1'''''''''''''''
101904+ state.addr = 18446744073709545394LLU; // 99999998cw'''''''''''''''
101864101905 break;
101865101906 }
101866- case 18446744073709545399LLU: // 99999998c1'''''''''''''''
101907+ case 18446744073709545394LLU: // 99999998cw'''''''''''''''
101867101908 {
101868101909 // parameter-reference defidfn___ previous__ goes out of scope
101869101910 // parameter-reference list<defidfn___> fndefs____ goes out of scope
101870- state.addr = 18446744073709545402LLU; // 99999998c4'''''''''''''''
101911+ state.addr = 18446744073709545397LLU; // 99999998cz'''''''''''''''
101871101912 break;
101872101913 }
101873- case 18446744073709545401LLU: // 99999998c3'''''''''''''''
101914+ case 18446744073709545396LLU: // 99999998cy'''''''''''''''
101874101915 {
101875- state.addr = !list_push_move(&heap, &/*current___*/*LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 13) ? 18446744073709545384LLU : 18446744073709545383LLU;
101916+ state.addr = !list_push_move(&heap, &/*current___*/*LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 13) ? 18446744073709545379LLU : 18446744073709545378LLU;
101876101917 break;
101877101918 }
101878- case 18446744073709545384LLU: // 99999998cm'''''''''''''''
101919+ case 18446744073709545379LLU: // 99999998ch'''''''''''''''
101879101920 {
101880101921 {
101881101922 uint64_t arg = *LOCAL_ACCESS(heap.data, 25LLU, 23LLU);
@@ -101896,7 +101937,7 @@
101896101937 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101897101938 }
101898101939 // ACCUMULATE ARGUMENTS - END
101899- uint64_t return_to = 18446744073709545382LLU;
101940+ uint64_t return_to = 18446744073709545377LLU;
101900101941 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101901101942 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101902101943 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101905,32 +101946,32 @@
101905101946 state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
101906101947 break;
101907101948 }
101908- case 18446744073709545382LLU: // 99999998ck'''''''''''''''
101949+ case 18446744073709545377LLU: // 99999998cf'''''''''''''''
101909101950 {
101910101951 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference current___ at 26
101911101952 heap.availilable_size_for_dynamic_objects += 0LLU;
101912101953 heap.availilable_size_for_dynamic_objects += 0LLU;
101913- state.addr = 18446744073709545381LLU; // 99999998cj'''''''''''''''
101954+ state.addr = 18446744073709545376LLU; // 99999998ce'''''''''''''''
101914101955 break;
101915101956 }
101916- case 18446744073709545383LLU: // 99999998cl'''''''''''''''
101957+ case 18446744073709545378LLU: // 99999998cg'''''''''''''''
101917101958 {
101918- state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545380LLU : 18446744073709545379LLU;
101959+ state.addr = /*fresh_____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545375LLU : 18446744073709545374LLU;
101919101960 break;
101920101961 }
101921- case 18446744073709545380LLU: // 99999998ci'''''''''''''''
101962+ case 18446744073709545375LLU: // 99999998cd'''''''''''''''
101922101963 {
101923101964 heap.availilable_size_for_dynamic_objects += 0LLU;
101924101965 heap.availilable_size_for_dynamic_objects += 0LLU;
101925- state.addr = 18446744073709545378LLU; // 99999998cg'''''''''''''''
101966+ state.addr = 18446744073709545373LLU; // 99999998cb'''''''''''''''
101926101967 break;
101927101968 }
101928- case 18446744073709545379LLU: // 99999998ch'''''''''''''''
101969+ case 18446744073709545374LLU: // 99999998cc'''''''''''''''
101929101970 {
101930- state.addr = /*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545377LLU : 18446744073709545376LLU;
101971+ state.addr = /*fndefs____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545372LLU : 18446744073709545371LLU;
101931101972 break;
101932101973 }
101933- case 18446744073709545377LLU: // 99999998cf'''''''''''''''
101974+ case 18446744073709545372LLU: // 99999998ca'''''''''''''''
101934101975 {
101935101976 {
101936101977 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU))/*list*/, 13);
@@ -101944,7 +101985,7 @@
101944101985 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
101945101986 }
101946101987 // ACCUMULATE ARGUMENTS - END
101947- uint64_t return_to = 18446744073709545375LLU;
101988+ uint64_t return_to = 18446744073709545370LLU;
101948101989 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
101949101990 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
101950101991 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -101953,39 +101994,39 @@
101953101994 state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
101954101995 break;
101955101996 }
101956- case 18446744073709545375LLU: // 99999998cd'''''''''''''''
101997+ case 18446744073709545370LLU: // 99999998cZ'''''''''''''''
101957101998 {
101958101999 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dummy_____ at 26
101959102000 heap.availilable_size_for_dynamic_objects += 0LLU;
101960102001 heap.availilable_size_for_dynamic_objects += 0LLU;
101961- state.addr = 18446744073709545374LLU; // 99999998cc'''''''''''''''
102002+ state.addr = 18446744073709545369LLU; // 99999998cY'''''''''''''''
101962102003 break;
101963102004 }
101964- case 18446744073709545376LLU: // 99999998ce'''''''''''''''
102005+ case 18446744073709545371LLU: // 99999998c$'''''''''''''''
101965102006 {
101966102007 {
101967102008 fprintf(stderr, "%s\n", "INTERNAL COMPILER ERROR in clumsy decl-replace-code: this should never happen!");
101968102009 exit(-1);
101969102010 }
101970- state.addr = 18446744073709545374LLU; // 99999998cc'''''''''''''''
102011+ state.addr = 18446744073709545369LLU; // 99999998cY'''''''''''''''
101971102012 break;
101972102013 }
101973- case 18446744073709545374LLU: // 99999998cc'''''''''''''''
102014+ case 18446744073709545369LLU: // 99999998cY'''''''''''''''
101974102015 {
101975- state.addr = 18446744073709545378LLU; // 99999998cg'''''''''''''''
102016+ state.addr = 18446744073709545373LLU; // 99999998cb'''''''''''''''
101976102017 break;
101977102018 }
101978- case 18446744073709545378LLU: // 99999998cg'''''''''''''''
102019+ case 18446744073709545373LLU: // 99999998cb'''''''''''''''
101979102020 {
101980- state.addr = 18446744073709545381LLU; // 99999998cj'''''''''''''''
102021+ state.addr = 18446744073709545376LLU; // 99999998ce'''''''''''''''
101981102022 break;
101982102023 }
101983- case 18446744073709545381LLU: // 99999998cj'''''''''''''''
102024+ case 18446744073709545376LLU: // 99999998ce'''''''''''''''
101984102025 {
101985- state.addr = 18446744073709545385LLU; // 99999998cn'''''''''''''''
102026+ state.addr = 18446744073709545380LLU; // 99999998ci'''''''''''''''
101986102027 break;
101987102028 }
101988- case 18446744073709545385LLU: // 99999998cn'''''''''''''''
102029+ case 18446744073709545380LLU: // 99999998ci'''''''''''''''
101989102030 {
101990102031 // variable u64 fresh_____ goes out of scope
101991102032 // emitted destructur for type u64
@@ -101993,15 +102034,15 @@
101993102034 // variable defidfn___ current___ goes out of scope
101994102035 // (uninitialized -> no destructor-call)
101995102036 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference current___ at 24
101996- state.addr = 18446744073709545405LLU; // 99999998c7'''''''''''''''
102037+ state.addr = 18446744073709545400LLU; // 99999998c2'''''''''''''''
101997102038 break;
101998102039 }
101999- case 18446744073709545405LLU: // 99999998c7'''''''''''''''
102040+ case 18446744073709545400LLU: // 99999998c2'''''''''''''''
102000102041 {
102001- state.addr = /*defined___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545373LLU : 18446744073709545372LLU;
102042+ state.addr = /*defined___*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545368LLU : 18446744073709545367LLU;
102002102043 break;
102003102044 }
102004- case 18446744073709545373LLU: // 99999998cb'''''''''''''''
102045+ case 18446744073709545368LLU: // 99999998cX'''''''''''''''
102005102046 {
102006102047 // ACCUMULATE ARGUMENTS - BEGIN
102007102048 {
@@ -102009,7 +102050,7 @@
102009102050 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102010102051 }
102011102052 // ACCUMULATE ARGUMENTS - END
102012- uint64_t return_to = 18446744073709545370LLU;
102053+ uint64_t return_to = 18446744073709545365LLU;
102013102054 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102014102055 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102015102056 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102018,12 +102059,12 @@
102018102059 state.addr = 587881345921715008LLU; // emitenter_
102019102060 break;
102020102061 }
102021- case 18446744073709545370LLU: // 99999998cZ'''''''''''''''
102062+ case 18446744073709545365LLU: // 99999998cU'''''''''''''''
102022102063 {
102023- state.addr = 18446744073709545371LLU; // 99999998c$'''''''''''''''
102064+ state.addr = 18446744073709545366LLU; // 99999998cV'''''''''''''''
102024102065 break;
102025102066 }
102026- case 18446744073709545371LLU: // 99999998c$'''''''''''''''
102067+ case 18446744073709545366LLU: // 99999998cV'''''''''''''''
102027102068 {
102028102069 // ACCUMULATE ARGUMENTS - BEGIN
102029102070 {
@@ -102031,7 +102072,7 @@
102031102072 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102032102073 }
102033102074 // ACCUMULATE ARGUMENTS - END
102034- uint64_t return_to = 18446744073709545368LLU;
102075+ uint64_t return_to = 18446744073709545363LLU;
102035102076 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102036102077 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102037102078 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102040,12 +102081,12 @@
102040102081 state.addr = 839519719621918720LLU; // skipws____
102041102082 break;
102042102083 }
102043- case 18446744073709545368LLU: // 99999998cX'''''''''''''''
102084+ case 18446744073709545363LLU: // 99999998cS'''''''''''''''
102044102085 {
102045- state.addr = 18446744073709545369LLU; // 99999998cY'''''''''''''''
102086+ state.addr = 18446744073709545364LLU; // 99999998cT'''''''''''''''
102046102087 break;
102047102088 }
102048- case 18446744073709545369LLU: // 99999998cY'''''''''''''''
102089+ case 18446744073709545364LLU: // 99999998cT'''''''''''''''
102049102090 {
102050102091 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 5LLU)), stdin);
102051102092 if('{' != (char)getchar())
@@ -102053,15 +102094,15 @@
102053102094 fprintf(stderr, "match failed at char %c\n", (char)123LLU);
102054102095 exit(-1);
102055102096 }
102056- state.addr = 18446744073709545367LLU; // 99999998cW'''''''''''''''
102097+ state.addr = 18446744073709545362LLU; // 99999998cR'''''''''''''''
102057102098 break;
102058102099 }
102059- case 18446744073709545367LLU: // 99999998cW'''''''''''''''
102100+ case 18446744073709545362LLU: // 99999998cR'''''''''''''''
102060102101 {
102061102102 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) = (uint64_t)getchar();
102062102103 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) > 255)
102063102104 {
102064- state.addr = 18446744073709545366LLU; // 99999998cV'''''''''''''''
102105+ state.addr = 18446744073709545361LLU; // 99999998cQ'''''''''''''''
102065102106 break;
102066102107 }
102067102108 // ACCUMULATE ARGUMENTS - BEGIN
@@ -102130,7 +102171,7 @@
102130102171 LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102131102172 }
102132102173 // ACCUMULATE ARGUMENTS - END
102133- uint64_t return_to = 18446744073709545364LLU;
102174+ uint64_t return_to = 18446744073709545359LLU;
102134102175 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0));
102135102176 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102136102177 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102139,40 +102180,40 @@
102139102180 state.addr = 782701543301228454LLU; // parseblock
102140102181 break;
102141102182 }
102142- case 18446744073709545364LLU: // 99999998cT'''''''''''''''
102183+ case 18446744073709545359LLU: // 99999998cO'''''''''''''''
102143102184 {
102144- state.addr = 18446744073709545365LLU; // 99999998cU'''''''''''''''
102185+ state.addr = 18446744073709545360LLU; // 99999998cP'''''''''''''''
102145102186 break;
102146102187 }
102147- case 18446744073709545365LLU: // 99999998cU'''''''''''''''
102188+ case 18446744073709545360LLU: // 99999998cP'''''''''''''''
102148102189 {
102149- state.addr = 18446744073709545367LLU; // 99999998cW'''''''''''''''
102190+ state.addr = 18446744073709545362LLU; // 99999998cR'''''''''''''''
102150102191 break;
102151102192 }
102152- case 18446744073709545366LLU: // 99999998cV'''''''''''''''
102193+ case 18446744073709545361LLU: // 99999998cQ'''''''''''''''
102153102194 {
102154- state.addr = /*varlist___*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545363LLU : 18446744073709545362LLU;
102195+ state.addr = /*varlist___*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545358LLU : 18446744073709545357LLU;
102155102196 break;
102156102197 }
102157- case 18446744073709545363LLU: // 99999998cS'''''''''''''''
102198+ case 18446744073709545358LLU: // 99999998cN'''''''''''''''
102158102199 {
102159102200 {
102160102201 fprintf(stderr, "%s\n", "INTERNAL ERROR: varlist not empty at end of definition\n");
102161102202 exit(-1);
102162102203 }
102163- state.addr = 18446744073709545362LLU; // 99999998cR'''''''''''''''
102204+ state.addr = 18446744073709545357LLU; // 99999998cM'''''''''''''''
102164102205 break;
102165102206 }
102166- case 18446744073709545362LLU: // 99999998cR'''''''''''''''
102207+ case 18446744073709545357LLU: // 99999998cM'''''''''''''''
102167102208 {
102168- state.addr = 18446744073709545361LLU; // 99999998cQ'''''''''''''''
102209+ state.addr = 18446744073709545356LLU; // 99999998cL'''''''''''''''
102169102210 break;
102170102211 }
102171- case 18446744073709545361LLU: // 99999998cQ'''''''''''''''
102212+ case 18446744073709545356LLU: // 99999998cL'''''''''''''''
102172102213 {
102173102214 if(!/*results___*/*LOCAL_ACCESS(heap.data, 23LLU, 17LLU))
102174102215 {
102175- state.addr = 18446744073709545360LLU; // 99999998cP'''''''''''''''
102216+ state.addr = 18446744073709545355LLU; // 99999998cK'''''''''''''''
102176102217 break;
102177102218 }
102178102219 {
@@ -102201,7 +102242,7 @@
102201102242 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102202102243 }
102203102244 // ACCUMULATE ARGUMENTS - END
102204- uint64_t return_to = 18446744073709545358LLU;
102245+ uint64_t return_to = 18446744073709545353LLU;
102205102246 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
102206102247 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102207102248 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102210,12 +102251,12 @@
102210102251 state.addr = 587881357748656161LLU; // emitpopref
102211102252 break;
102212102253 }
102213- case 18446744073709545358LLU: // 99999998cN'''''''''''''''
102254+ case 18446744073709545353LLU: // 99999998cI'''''''''''''''
102214102255 {
102215- state.addr = 18446744073709545359LLU; // 99999998cO'''''''''''''''
102256+ state.addr = 18446744073709545354LLU; // 99999998cJ'''''''''''''''
102216102257 break;
102217102258 }
102218- case 18446744073709545359LLU: // 99999998cO'''''''''''''''
102259+ case 18446744073709545354LLU: // 99999998cJ'''''''''''''''
102219102260 {
102220102261 // variable u64 resultid__ goes out of scope
102221102262 // emitted destructur for type u64
@@ -102229,7 +102270,7 @@
102229102270 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102230102271 }
102231102272 // ACCUMULATE ARGUMENTS - END
102232- uint64_t return_to = 18446744073709545357LLU;
102273+ uint64_t return_to = 18446744073709545352LLU;
102233102274 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102234102275 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102235102276 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102238,13 +102279,13 @@
102238102279 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
102239102280 break;
102240102281 }
102241- case 18446744073709545357LLU: // 99999998cM'''''''''''''''
102282+ case 18446744073709545352LLU: // 99999998cH'''''''''''''''
102242102283 {
102243102284 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference respar____ at 24
102244- state.addr = 18446744073709545361LLU; // 99999998cQ'''''''''''''''
102285+ state.addr = 18446744073709545356LLU; // 99999998cL'''''''''''''''
102245102286 break;
102246102287 }
102247- case 18446744073709545360LLU: // 99999998cP'''''''''''''''
102288+ case 18446744073709545355LLU: // 99999998cK'''''''''''''''
102248102289 {
102249102290 // ACCUMULATE ARGUMENTS - BEGIN
102250102291 {
@@ -102260,7 +102301,7 @@
102260102301 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102261102302 }
102262102303 // ACCUMULATE ARGUMENTS - END
102263- uint64_t return_to = 18446744073709545355LLU;
102304+ uint64_t return_to = 18446744073709545350LLU;
102264102305 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
102265102306 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102266102307 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102269,24 +102310,24 @@
102269102310 state.addr = 587881353282000896LLU; // emitleave_
102270102311 break;
102271102312 }
102272- case 18446744073709545355LLU: // 99999998cK'''''''''''''''
102313+ case 18446744073709545350LLU: // 99999998cF'''''''''''''''
102273102314 {
102274- state.addr = 18446744073709545356LLU; // 99999998cL'''''''''''''''
102315+ state.addr = 18446744073709545351LLU; // 99999998cG'''''''''''''''
102275102316 break;
102276102317 }
102277- case 18446744073709545356LLU: // 99999998cL'''''''''''''''
102318+ case 18446744073709545351LLU: // 99999998cG'''''''''''''''
102278102319 {
102279102320 heap.availilable_size_for_dynamic_objects += 0LLU;
102280102321 heap.availilable_size_for_dynamic_objects += 0LLU;
102281- state.addr = 18446744073709545354LLU; // 99999998cJ'''''''''''''''
102322+ state.addr = 18446744073709545349LLU; // 99999998cE'''''''''''''''
102282102323 break;
102283102324 }
102284- case 18446744073709545372LLU: // 99999998ca'''''''''''''''
102325+ case 18446744073709545367LLU: // 99999998cW'''''''''''''''
102285102326 {
102286- state.addr = 18446744073709545354LLU; // 99999998cJ'''''''''''''''
102327+ state.addr = 18446744073709545349LLU; // 99999998cE'''''''''''''''
102287102328 break;
102288102329 }
102289- case 18446744073709545354LLU: // 99999998cJ'''''''''''''''
102330+ case 18446744073709545349LLU: // 99999998cE'''''''''''''''
102290102331 {
102291102332 // variable u64 defined___ goes out of scope
102292102333 // emitted destructur for type u64
@@ -102293,14 +102334,14 @@
102293102334 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defined___ at 23
102294102335 // variable list<varentry__> varlist___ goes out of scope
102295102336 // emitted destructur for type list<varentry__>
102296- state.addr = 18446744073709545352LLU; // 99999998cH'''''''''''''''
102337+ state.addr = 18446744073709545347LLU; // 99999998cC'''''''''''''''
102297102338 break;
102298102339 }
102299- case 18446744073709545352LLU: // 99999998cH'''''''''''''''
102340+ case 18446744073709545347LLU: // 99999998cC'''''''''''''''
102300102341 {
102301102342 if(!*LOCAL_ACCESS(heap.data, 22LLU, 21LLU)/*list*/)
102302102343 {
102303- state.addr = 18446744073709545353LLU; // 99999998cI'''''''''''''''
102344+ state.addr = 18446744073709545348LLU; // 99999998cD'''''''''''''''
102304102345 break;
102305102346 }
102306102347 // temporary list-element
@@ -102314,7 +102355,7 @@
102314102355 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102315102356 }
102316102357 // ACCUMULATE ARGUMENTS - END
102317- uint64_t return_to = 18446744073709545351LLU;
102358+ uint64_t return_to = 18446744073709545346LLU;
102318102359 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102319102360 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102320102361 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102323,20 +102364,20 @@
102323102364 state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
102324102365 break;
102325102366 }
102326- case 18446744073709545351LLU: // 99999998cG'''''''''''''''
102367+ case 18446744073709545346LLU: // 99999998cB'''''''''''''''
102327102368 {
102328102369 // RELEASE temporary destructor-variable
102329102370 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
102330- state.addr = 18446744073709545352LLU; // 99999998cH'''''''''''''''
102371+ state.addr = 18446744073709545347LLU; // 99999998cC'''''''''''''''
102331102372 break;
102332102373 }
102333- case 18446744073709545353LLU: // 99999998cI'''''''''''''''
102374+ case 18446744073709545348LLU: // 99999998cD'''''''''''''''
102334102375 {
102335102376 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varlist___ at 22
102336- state.addr = 18446744073709545422LLU; // 99999998dN'''''''''''''''
102377+ state.addr = 18446744073709545417LLU; // 99999998dI'''''''''''''''
102337102378 break;
102338102379 }
102339- case 18446744073709545422LLU: // 99999998dN'''''''''''''''
102380+ case 18446744073709545417LLU: // 99999998dI'''''''''''''''
102340102381 {
102341102382 // variable u64 matchsym__ goes out of scope
102342102383 // emitted destructur for type u64
@@ -102346,14 +102387,14 @@
102346102387 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 20
102347102388 // variable list<pardef____> defpars___ goes out of scope
102348102389 // emitted destructur for type list<pardef____>
102349- state.addr = 18446744073709545349LLU; // 99999998cE'''''''''''''''
102390+ state.addr = 18446744073709545344LLU; // 99999998c_'''''''''''''''
102350102391 break;
102351102392 }
102352- case 18446744073709545349LLU: // 99999998cE'''''''''''''''
102393+ case 18446744073709545344LLU: // 99999998c_'''''''''''''''
102353102394 {
102354102395 if(!*LOCAL_ACCESS(heap.data, 19LLU, 18LLU)/*list*/)
102355102396 {
102356- state.addr = 18446744073709545350LLU; // 99999998cF'''''''''''''''
102397+ state.addr = 18446744073709545345LLU; // 99999998cA'''''''''''''''
102357102398 break;
102358102399 }
102359102400 // temporary list-element
@@ -102367,7 +102408,7 @@
102367102408 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102368102409 }
102369102410 // ACCUMULATE ARGUMENTS - END
102370- uint64_t return_to = 18446744073709545348LLU;
102411+ uint64_t return_to = 18446744073709545343LLU;
102371102412 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102372102413 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102373102414 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102376,26 +102417,26 @@
102376102417 state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
102377102418 break;
102378102419 }
102379- case 18446744073709545348LLU: // 99999998cD'''''''''''''''
102420+ case 18446744073709545343LLU: // 99999998b9'''''''''''''''
102380102421 {
102381102422 // RELEASE temporary destructor-variable
102382102423 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20
102383- state.addr = 18446744073709545349LLU; // 99999998cE'''''''''''''''
102424+ state.addr = 18446744073709545344LLU; // 99999998c_'''''''''''''''
102384102425 break;
102385102426 }
102386- case 18446744073709545350LLU: // 99999998cF'''''''''''''''
102427+ case 18446744073709545345LLU: // 99999998cA'''''''''''''''
102387102428 {
102388102429 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defpars___ at 19
102389102430 // variable list<resdest___> results___ goes out of scope
102390102431 // emitted destructur for type list<resdest___>
102391- state.addr = 18446744073709545346LLU; // 99999998cB'''''''''''''''
102432+ state.addr = 18446744073709545341LLU; // 99999998b7'''''''''''''''
102392102433 break;
102393102434 }
102394- case 18446744073709545346LLU: // 99999998cB'''''''''''''''
102435+ case 18446744073709545341LLU: // 99999998b7'''''''''''''''
102395102436 {
102396102437 if(!*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/*list*/)
102397102438 {
102398- state.addr = 18446744073709545347LLU; // 99999998cC'''''''''''''''
102439+ state.addr = 18446744073709545342LLU; // 99999998b8'''''''''''''''
102399102440 break;
102400102441 }
102401102442 // temporary list-element
@@ -102409,7 +102450,7 @@
102409102450 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102410102451 }
102411102452 // ACCUMULATE ARGUMENTS - END
102412- uint64_t return_to = 18446744073709545345LLU;
102453+ uint64_t return_to = 18446744073709545340LLU;
102413102454 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102414102455 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102415102456 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102418,14 +102459,14 @@
102418102459 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
102419102460 break;
102420102461 }
102421- case 18446744073709545345LLU: // 99999998cA'''''''''''''''
102462+ case 18446744073709545340LLU: // 99999998b6'''''''''''''''
102422102463 {
102423102464 // RELEASE temporary destructor-variable
102424102465 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
102425- state.addr = 18446744073709545346LLU; // 99999998cB'''''''''''''''
102466+ state.addr = 18446744073709545341LLU; // 99999998b7'''''''''''''''
102426102467 break;
102427102468 }
102428- case 18446744073709545347LLU: // 99999998cC'''''''''''''''
102469+ case 18446744073709545342LLU: // 99999998b8'''''''''''''''
102429102470 {
102430102471 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 18
102431102472 // variable u64 remainheap goes out of scope
@@ -102449,18 +102490,18 @@
102449102490 // variable u64 finite____ goes out of scope
102450102491 // emitted destructur for type u64
102451102492 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference finite____ at 11
102452- state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
102493+ state.addr = 18446744073709545559LLU; // 99999998fW'''''''''''''''
102453102494 break;
102454102495 }
102455- case 18446744073709545564LLU: // 99999998fa'''''''''''''''
102496+ case 18446744073709545559LLU: // 99999998fW'''''''''''''''
102456102497 {
102457102498 // variable u64 isunion___ goes out of scope
102458102499 // emitted destructur for type u64
102459102500 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference isunion___ at 10
102460- state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
102501+ state.addr = 18446744073709545677LLU; // 99999998hM'''''''''''''''
102461102502 break;
102462102503 }
102463- case 18446744073709545682LLU: // 99999998hR'''''''''''''''
102504+ case 18446744073709545677LLU: // 99999998hM'''''''''''''''
102464102505 {
102465102506 // variable u64 isstruct__ goes out of scope
102466102507 // emitted destructur for type u64
@@ -102468,10 +102509,10 @@
102468102509 // variable u64 def_id____ goes out of scope
102469102510 // emitted destructur for type u64
102470102511 (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 8
102471- state.addr = 18446744073709545764LLU; // 99999998ii'''''''''''''''
102512+ state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
102472102513 break;
102473102514 }
102474- case 18446744073709545764LLU: // 99999998ii'''''''''''''''
102515+ case 18446744073709545759LLU: // 99999998id'''''''''''''''
102475102516 {
102476102517 // variable u64 buf_______ goes out of scope
102477102518 // emitted destructur for type u64
@@ -102512,7 +102553,7 @@
102512102553 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102513102554 }
102514102555 // ACCUMULATE ARGUMENTS - END
102515- uint64_t return_to = 18446744073709545343LLU;
102556+ uint64_t return_to = 18446744073709545338LLU;
102516102557 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
102517102558 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102518102559 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102521,24 +102562,24 @@
102521102562 state.addr = 661671490923528192LLU; // isspace___
102522102563 break;
102523102564 }
102524- case 18446744073709545343LLU: // 99999998b9'''''''''''''''
102565+ case 18446744073709545338LLU: // 99999998b4'''''''''''''''
102525102566 {
102526- state.addr = 18446744073709545344LLU; // 99999998c_'''''''''''''''
102567+ state.addr = 18446744073709545339LLU; // 99999998b5'''''''''''''''
102527102568 break;
102528102569 }
102529- case 18446744073709545344LLU: // 99999998c_'''''''''''''''
102570+ case 18446744073709545339LLU: // 99999998b5'''''''''''''''
102530102571 {
102531- state.addr = /*result0___*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545342LLU : 18446744073709545341LLU;
102572+ state.addr = /*result0___*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545337LLU : 18446744073709545336LLU;
102532102573 break;
102533102574 }
102534- case 18446744073709545342LLU: // 99999998b8'''''''''''''''
102575+ case 18446744073709545337LLU: // 99999998b3'''''''''''''''
102535102576 {
102536102577 heap.availilable_size_for_dynamic_objects += 0LLU;
102537102578 heap.availilable_size_for_dynamic_objects += 0LLU;
102538- state.addr = 18446744073709545340LLU; // 99999998b6'''''''''''''''
102579+ state.addr = 18446744073709545335LLU; // 99999998b1'''''''''''''''
102539102580 break;
102540102581 }
102541- case 18446744073709545341LLU: // 99999998b7'''''''''''''''
102582+ case 18446744073709545336LLU: // 99999998b2'''''''''''''''
102542102583 {
102543102584 {
102544102585 uint64_t arg = 0LLU;
@@ -102556,10 +102597,10 @@
102556102597
102557102598 /*result1___*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU) = /*result0___*/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) == /*peek______*/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU);
102558102599 /*result0___*/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) = /*result0___*/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) && /*result1___*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
102559- state.addr = /*result0___*/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) ? 18446744073709545339LLU : 18446744073709545338LLU;
102600+ state.addr = /*result0___*/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) ? 18446744073709545334LLU : 18446744073709545333LLU;
102560102601 break;
102561102602 }
102562- case 18446744073709545339LLU: // 99999998b5'''''''''''''''
102603+ case 18446744073709545334LLU: // 99999998b0'''''''''''''''
102563102604 {
102564102605 // ACCUMULATE ARGUMENTS - BEGIN
102565102606 {
@@ -102567,7 +102608,7 @@
102567102608 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102568102609 }
102569102610 // ACCUMULATE ARGUMENTS - END
102570- uint64_t return_to = 18446744073709545336LLU;
102611+ uint64_t return_to = 18446744073709545331LLU;
102571102612 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102572102613 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102573102614 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102576,19 +102617,19 @@
102576102617 state.addr = 552432610005745664LLU; // comment___
102577102618 break;
102578102619 }
102579- case 18446744073709545336LLU: // 99999998b2'''''''''''''''
102620+ case 18446744073709545331LLU: // 99999998bx'''''''''''''''
102580102621 {
102581- state.addr = 18446744073709545337LLU; // 99999998b3'''''''''''''''
102622+ state.addr = 18446744073709545332LLU; // 99999998by'''''''''''''''
102582102623 break;
102583102624 }
102584- case 18446744073709545337LLU: // 99999998b3'''''''''''''''
102625+ case 18446744073709545332LLU: // 99999998by'''''''''''''''
102585102626 {
102586102627 heap.availilable_size_for_dynamic_objects += 0LLU;
102587102628 heap.availilable_size_for_dynamic_objects += 0LLU;
102588- state.addr = 18446744073709545335LLU; // 99999998b1'''''''''''''''
102629+ state.addr = 18446744073709545330LLU; // 99999998bw'''''''''''''''
102589102630 break;
102590102631 }
102591- case 18446744073709545338LLU: // 99999998b4'''''''''''''''
102632+ case 18446744073709545333LLU: // 99999998bz'''''''''''''''
102592102633 {
102593102634 // ACCUMULATE ARGUMENTS - BEGIN
102594102635 {
@@ -102616,7 +102657,7 @@
102616102657 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102617102658 }
102618102659 // ACCUMULATE ARGUMENTS - END
102619- uint64_t return_to = 18446744073709545333LLU;
102660+ uint64_t return_to = 18446744073709545328LLU;
102620102661 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
102621102662 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102622102663 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102625,17 +102666,17 @@
102625102666 state.addr = 782701543332909056LLU; // parsedef__
102626102667 break;
102627102668 }
102628- case 18446744073709545333LLU: // 99999998bz'''''''''''''''
102669+ case 18446744073709545328LLU: // 99999998bu'''''''''''''''
102629102670 {
102630- state.addr = 18446744073709545334LLU; // 99999998b0'''''''''''''''
102671+ state.addr = 18446744073709545329LLU; // 99999998bv'''''''''''''''
102631102672 break;
102632102673 }
102633- case 18446744073709545334LLU: // 99999998b0'''''''''''''''
102674+ case 18446744073709545329LLU: // 99999998bv'''''''''''''''
102634102675 {
102635- state.addr = 18446744073709545335LLU; // 99999998b1'''''''''''''''
102676+ state.addr = 18446744073709545330LLU; // 99999998bw'''''''''''''''
102636102677 break;
102637102678 }
102638- case 18446744073709545335LLU: // 99999998b1'''''''''''''''
102679+ case 18446744073709545330LLU: // 99999998bw'''''''''''''''
102639102680 {
102640102681 // variable u64 peek______ goes out of scope
102641102682 // emitted destructur for type u64
@@ -102643,10 +102684,10 @@
102643102684 // variable u64 result1___ goes out of scope
102644102685 // emitted destructur for type u64
102645102686 (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result1___ at 8
102646- state.addr = 18446744073709545340LLU; // 99999998b6'''''''''''''''
102687+ state.addr = 18446744073709545335LLU; // 99999998b1'''''''''''''''
102647102688 break;
102648102689 }
102649- case 18446744073709545340LLU: // 99999998b6'''''''''''''''
102690+ case 18446744073709545335LLU: // 99999998b1'''''''''''''''
102650102691 {
102651102692 // variable u64 result0___ goes out of scope
102652102693 // emitted destructur for type u64
@@ -102699,7 +102740,7 @@
102699102740 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102700102741 }
102701102742 // ACCUMULATE ARGUMENTS - END
102702- uint64_t return_to = 18446744073709545331LLU;
102743+ uint64_t return_to = 18446744073709545326LLU;
102703102744 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
102704102745 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102705102746 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102708,22 +102749,22 @@
102708102749 state.addr = 782701543332912000LLU; // parsedefs_
102709102750 break;
102710102751 }
102711- case 18446744073709545331LLU: // 99999998bx'''''''''''''''
102752+ case 18446744073709545326LLU: // 99999998bs'''''''''''''''
102712102753 {
102713- state.addr = 18446744073709545332LLU; // 99999998by'''''''''''''''
102754+ state.addr = 18446744073709545327LLU; // 99999998bt'''''''''''''''
102714102755 break;
102715102756 }
102716- case 18446744073709545332LLU: // 99999998by'''''''''''''''
102757+ case 18446744073709545327LLU: // 99999998bt'''''''''''''''
102717102758 {
102718- state.addr = 18446744073709545330LLU; // 99999998bw'''''''''''''''
102759+ state.addr = 18446744073709545325LLU; // 99999998br'''''''''''''''
102719102760 break;
102720102761 }
102721- case 18446744073709545330LLU: // 99999998bw'''''''''''''''
102762+ case 18446744073709545325LLU: // 99999998br'''''''''''''''
102722102763 {
102723102764 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) = (uint64_t)getchar();
102724102765 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) > 255)
102725102766 {
102726- state.addr = 18446744073709545329LLU; // 99999998bv'''''''''''''''
102767+ state.addr = 18446744073709545324LLU; // 99999998bq'''''''''''''''
102727102768 break;
102728102769 }
102729102770 // ACCUMULATE ARGUMENTS - BEGIN
@@ -102752,7 +102793,7 @@
102752102793 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102753102794 }
102754102795 // ACCUMULATE ARGUMENTS - END
102755- uint64_t return_to = 18446744073709545327LLU;
102796+ uint64_t return_to = 18446744073709545322LLU;
102756102797 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
102757102798 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102758102799 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102761,17 +102802,17 @@
102761102802 state.addr = 782701543332912000LLU; // parsedefs_
102762102803 break;
102763102804 }
102764- case 18446744073709545327LLU: // 99999998bt'''''''''''''''
102805+ case 18446744073709545322LLU: // 99999998bo'''''''''''''''
102765102806 {
102766- state.addr = 18446744073709545328LLU; // 99999998bu'''''''''''''''
102807+ state.addr = 18446744073709545323LLU; // 99999998bp'''''''''''''''
102767102808 break;
102768102809 }
102769- case 18446744073709545328LLU: // 99999998bu'''''''''''''''
102810+ case 18446744073709545323LLU: // 99999998bp'''''''''''''''
102770102811 {
102771- state.addr = 18446744073709545330LLU; // 99999998bw'''''''''''''''
102812+ state.addr = 18446744073709545325LLU; // 99999998br'''''''''''''''
102772102813 break;
102773102814 }
102774- case 18446744073709545329LLU: // 99999998bv'''''''''''''''
102815+ case 18446744073709545324LLU: // 99999998bq'''''''''''''''
102775102816 {
102776102817 // parameter-reference u64 lookahead_ goes out of scope
102777102818 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 6
@@ -102818,7 +102859,7 @@
102818102859 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102819102860 }
102820102861 // ACCUMULATE ARGUMENTS - END
102821- uint64_t return_to = 18446744073709545325LLU;
102862+ uint64_t return_to = 18446744073709545320LLU;
102822102863 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102823102864 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102824102865 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102827,12 +102868,12 @@
102827102868 state.addr = 839519719621918720LLU; // skipws____
102828102869 break;
102829102870 }
102830- case 18446744073709545325LLU: // 99999998br'''''''''''''''
102871+ case 18446744073709545320LLU: // 99999998bm'''''''''''''''
102831102872 {
102832- state.addr = 18446744073709545326LLU; // 99999998bs'''''''''''''''
102873+ state.addr = 18446744073709545321LLU; // 99999998bn'''''''''''''''
102833102874 break;
102834102875 }
102835- case 18446744073709545326LLU: // 99999998bs'''''''''''''''
102876+ case 18446744073709545321LLU: // 99999998bn'''''''''''''''
102836102877 {
102837102878 {
102838102879 uint64_t arg = 96LLU;
@@ -102843,35 +102884,35 @@
102843102884 LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
102844102885 }
102845102886 /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) == /*c_________*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
102846- state.addr = /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545323LLU : 18446744073709545322LLU;
102887+ state.addr = /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545318LLU : 18446744073709545317LLU;
102847102888 break;
102848102889 }
102849- case 18446744073709545323LLU: // 99999998bp'''''''''''''''
102890+ case 18446744073709545318LLU: // 99999998bk'''''''''''''''
102850102891 {
102851- state.addr = 18446744073709545321LLU; // 99999998bn'''''''''''''''
102892+ state.addr = 18446744073709545316LLU; // 99999998bi'''''''''''''''
102852102893 break;
102853102894 }
102854- case 18446744073709545321LLU: // 99999998bn'''''''''''''''
102895+ case 18446744073709545316LLU: // 99999998bi'''''''''''''''
102855102896 {
102856102897 *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = (uint64_t)getchar();
102857102898 if(!*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) || *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) > 255)
102858102899 {
102859- state.addr = 18446744073709545320LLU; // 99999998bm'''''''''''''''
102900+ state.addr = 18446744073709545315LLU; // 99999998bh'''''''''''''''
102860102901 break;
102861102902 }
102862102903 /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) == /*c_________*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
102863- state.addr = /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545319LLU : 18446744073709545318LLU;
102904+ state.addr = /*toggle_ext*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545314LLU : 18446744073709545313LLU;
102864102905 break;
102865102906 }
102866- case 18446744073709545319LLU: // 99999998bl'''''''''''''''
102907+ case 18446744073709545314LLU: // 99999998bg'''''''''''''''
102867102908 {
102868102909 ungetc(0, stdin);
102869102910 heap.availilable_size_for_dynamic_objects += 0LLU;
102870102911 heap.availilable_size_for_dynamic_objects += 0LLU;
102871- state.addr = 18446744073709545317LLU; // 99999998bj'''''''''''''''
102912+ state.addr = 18446744073709545312LLU; // 99999998be'''''''''''''''
102872102913 break;
102873102914 }
102874- case 18446744073709545318LLU: // 99999998bk'''''''''''''''
102915+ case 18446744073709545313LLU: // 99999998bf'''''''''''''''
102875102916 {
102876102917 // ACCUMULATE ARGUMENTS - BEGIN
102877102918 {
@@ -102879,7 +102920,7 @@
102879102920 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102880102921 }
102881102922 // ACCUMULATE ARGUMENTS - END
102882- uint64_t return_to = 18446744073709545315LLU;
102923+ uint64_t return_to = 18446744073709545310LLU;
102883102924 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102884102925 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102885102926 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102888,28 +102929,28 @@
102888102929 state.addr = 587881343588366336LLU; // emitccode_
102889102930 break;
102890102931 }
102891- case 18446744073709545315LLU: // 99999998bh'''''''''''''''
102932+ case 18446744073709545310LLU: // 99999998bc'''''''''''''''
102892102933 {
102893- state.addr = 18446744073709545316LLU; // 99999998bi'''''''''''''''
102934+ state.addr = 18446744073709545311LLU; // 99999998bd'''''''''''''''
102894102935 break;
102895102936 }
102896- case 18446744073709545316LLU: // 99999998bi'''''''''''''''
102937+ case 18446744073709545311LLU: // 99999998bd'''''''''''''''
102897102938 {
102898- state.addr = 18446744073709545317LLU; // 99999998bj'''''''''''''''
102939+ state.addr = 18446744073709545312LLU; // 99999998be'''''''''''''''
102899102940 break;
102900102941 }
102901- case 18446744073709545317LLU: // 99999998bj'''''''''''''''
102942+ case 18446744073709545312LLU: // 99999998be'''''''''''''''
102902102943 {
102903- state.addr = 18446744073709545321LLU; // 99999998bn'''''''''''''''
102944+ state.addr = 18446744073709545316LLU; // 99999998bi'''''''''''''''
102904102945 break;
102905102946 }
102906- case 18446744073709545320LLU: // 99999998bm'''''''''''''''
102947+ case 18446744073709545315LLU: // 99999998bh'''''''''''''''
102907102948 {
102908102949 /*c_________*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = (uint64_t)getchar();
102909- state.addr = 18446744073709545322LLU; // 99999998bo'''''''''''''''
102950+ state.addr = 18446744073709545317LLU; // 99999998bj'''''''''''''''
102910102951 break;
102911102952 }
102912- case 18446744073709545322LLU: // 99999998bo'''''''''''''''
102953+ case 18446744073709545317LLU: // 99999998bj'''''''''''''''
102913102954 {
102914102955 // variable u64 toggle_ext goes out of scope
102915102956 // emitted destructur for type u64
@@ -102917,10 +102958,10 @@
102917102958 // variable u64 sym_______ goes out of scope
102918102959 // emitted destructur for type u64
102919102960 (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
102920- state.addr = 18446744073709545324LLU; // 99999998bq'''''''''''''''
102961+ state.addr = 18446744073709545319LLU; // 99999998bl'''''''''''''''
102921102962 break;
102922102963 }
102923- case 18446744073709545324LLU: // 99999998bq'''''''''''''''
102964+ case 18446744073709545319LLU: // 99999998bl'''''''''''''''
102924102965 {
102925102966 // ACCUMULATE ARGUMENTS - BEGIN
102926102967 {
@@ -102928,7 +102969,7 @@
102928102969 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102929102970 }
102930102971 // ACCUMULATE ARGUMENTS - END
102931- uint64_t return_to = 18446744073709545313LLU;
102972+ uint64_t return_to = 18446744073709545308LLU;
102932102973 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102933102974 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102934102975 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102937,12 +102978,12 @@
102937102978 state.addr = 839519719621918720LLU; // skipws____
102938102979 break;
102939102980 }
102940- case 18446744073709545313LLU: // 99999998bf'''''''''''''''
102981+ case 18446744073709545308LLU: // 99999998ba'''''''''''''''
102941102982 {
102942- state.addr = 18446744073709545314LLU; // 99999998bg'''''''''''''''
102983+ state.addr = 18446744073709545309LLU; // 99999998bb'''''''''''''''
102943102984 break;
102944102985 }
102945- case 18446744073709545314LLU: // 99999998bg'''''''''''''''
102986+ case 18446744073709545309LLU: // 99999998bb'''''''''''''''
102946102987 {
102947102988 // ACCUMULATE ARGUMENTS - BEGIN
102948102989 {
@@ -102950,7 +102991,7 @@
102950102991 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102951102992 }
102952102993 // ACCUMULATE ARGUMENTS - END
102953- uint64_t return_to = 18446744073709545311LLU;
102994+ uint64_t return_to = 18446744073709545306LLU;
102954102995 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102955102996 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102956102997 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102959,12 +103000,12 @@
102959103000 state.addr = 552432610005975040LLU; // comment2__
102960103001 break;
102961103002 }
102962- case 18446744073709545311LLU: // 99999998bd'''''''''''''''
103003+ case 18446744073709545306LLU: // 99999998bZ'''''''''''''''
102963103004 {
102964- state.addr = 18446744073709545312LLU; // 99999998be'''''''''''''''
103005+ state.addr = 18446744073709545307LLU; // 99999998b$'''''''''''''''
102965103006 break;
102966103007 }
102967- case 18446744073709545312LLU: // 99999998be'''''''''''''''
103008+ case 18446744073709545307LLU: // 99999998b$'''''''''''''''
102968103009 {
102969103010 // ACCUMULATE ARGUMENTS - BEGIN
102970103011 {
@@ -102972,7 +103013,7 @@
102972103013 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102973103014 }
102974103015 // ACCUMULATE ARGUMENTS - END
102975- uint64_t return_to = 18446744073709545309LLU;
103016+ uint64_t return_to = 18446744073709545304LLU;
102976103017 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
102977103018 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
102978103019 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -102981,12 +103022,12 @@
102981103022 state.addr = 839519719621918720LLU; // skipws____
102982103023 break;
102983103024 }
102984- case 18446744073709545309LLU: // 99999998bb'''''''''''''''
103025+ case 18446744073709545304LLU: // 99999998bX'''''''''''''''
102985103026 {
102986- state.addr = 18446744073709545310LLU; // 99999998bc'''''''''''''''
103027+ state.addr = 18446744073709545305LLU; // 99999998bY'''''''''''''''
102987103028 break;
102988103029 }
102989- case 18446744073709545310LLU: // 99999998bc'''''''''''''''
103030+ case 18446744073709545305LLU: // 99999998bY'''''''''''''''
102990103031 {
102991103032 matchid("memory", &/*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
102992103033 // ACCUMULATE ARGUMENTS - BEGIN
@@ -102995,7 +103036,7 @@
102995103036 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
102996103037 }
102997103038 // ACCUMULATE ARGUMENTS - END
102998- uint64_t return_to = 18446744073709545307LLU;
103039+ uint64_t return_to = 18446744073709545302LLU;
102999103040 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103000103041 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103001103042 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103004,12 +103045,12 @@
103004103045 state.addr = 839519719621918720LLU; // skipws____
103005103046 break;
103006103047 }
103007- case 18446744073709545307LLU: // 99999998b$'''''''''''''''
103048+ case 18446744073709545302LLU: // 99999998bV'''''''''''''''
103008103049 {
103009- state.addr = 18446744073709545308LLU; // 99999998ba'''''''''''''''
103050+ state.addr = 18446744073709545303LLU; // 99999998bW'''''''''''''''
103010103051 break;
103011103052 }
103012- case 18446744073709545308LLU: // 99999998ba'''''''''''''''
103053+ case 18446744073709545303LLU: // 99999998bW'''''''''''''''
103013103054 {
103014103055 matchid("=", &/*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
103015103056 // ACCUMULATE ARGUMENTS - BEGIN
@@ -103018,7 +103059,7 @@
103018103059 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103019103060 }
103020103061 // ACCUMULATE ARGUMENTS - END
103021- uint64_t return_to = 18446744073709545305LLU;
103062+ uint64_t return_to = 18446744073709545300LLU;
103022103063 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103023103064 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103024103065 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103027,12 +103068,12 @@
103027103068 state.addr = 839519719621918720LLU; // skipws____
103028103069 break;
103029103070 }
103030- case 18446744073709545305LLU: // 99999998bY'''''''''''''''
103071+ case 18446744073709545300LLU: // 99999998bT'''''''''''''''
103031103072 {
103032- state.addr = 18446744073709545306LLU; // 99999998bZ'''''''''''''''
103073+ state.addr = 18446744073709545301LLU; // 99999998bU'''''''''''''''
103033103074 break;
103034103075 }
103035- case 18446744073709545306LLU: // 99999998bZ'''''''''''''''
103076+ case 18446744073709545301LLU: // 99999998bU'''''''''''''''
103036103077 {
103037103078 {
103038103079 uint64_t arg = 0LLU;
@@ -103045,7 +103086,7 @@
103045103086 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103046103087 }
103047103088 // ACCUMULATE ARGUMENTS - END
103048- uint64_t return_to = 18446744073709545303LLU;
103089+ uint64_t return_to = 18446744073709545298LLU;
103049103090 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103050103091 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103051103092 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103054,12 +103095,12 @@
103054103095 state.addr = 839519719621918720LLU; // skipws____
103055103096 break;
103056103097 }
103057- case 18446744073709545303LLU: // 99999998bW'''''''''''''''
103098+ case 18446744073709545298LLU: // 99999998bR'''''''''''''''
103058103099 {
103059- state.addr = 18446744073709545304LLU; // 99999998bX'''''''''''''''
103100+ state.addr = 18446744073709545299LLU; // 99999998bS'''''''''''''''
103060103101 break;
103061103102 }
103062- case 18446744073709545304LLU: // 99999998bX'''''''''''''''
103103+ case 18446744073709545299LLU: // 99999998bS'''''''''''''''
103063103104 {
103064103105 {
103065103106 uint64_t arg = 0LLU;
@@ -103070,7 +103111,7 @@
103070103111 ++/*heapsize__*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
103071103112 // ACCUMULATE ARGUMENTS - BEGIN
103072103113 // ACCUMULATE ARGUMENTS - END
103073- uint64_t return_to = 18446744073709545301LLU;
103114+ uint64_t return_to = 18446744073709545296LLU;
103074103115 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
103075103116 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103076103117 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103079,12 +103120,12 @@
103079103120 state.addr = 660268666046119936LLU; // intro_____
103080103121 break;
103081103122 }
103082- case 18446744073709545301LLU: // 99999998bU'''''''''''''''
103123+ case 18446744073709545296LLU: // 99999998bP'''''''''''''''
103083103124 {
103084- state.addr = 18446744073709545302LLU; // 99999998bV'''''''''''''''
103125+ state.addr = 18446744073709545297LLU; // 99999998bQ'''''''''''''''
103085103126 break;
103086103127 }
103087- case 18446744073709545302LLU: // 99999998bV'''''''''''''''
103128+ case 18446744073709545297LLU: // 99999998bQ'''''''''''''''
103088103129 {
103089103130 {
103090103131 uint64_t arg = 0LLU;
@@ -103104,7 +103145,7 @@
103104103145 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103105103146 }
103106103147 // ACCUMULATE ARGUMENTS - END
103107- uint64_t return_to = 18446744073709545299LLU;
103148+ uint64_t return_to = 18446744073709545294LLU;
103108103149 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
103109103150 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103110103151 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103113,12 +103154,12 @@
103113103154 state.addr = 517555828430075934LLU; // assign_dec
103114103155 break;
103115103156 }
103116- case 18446744073709545299LLU: // 99999998bS'''''''''''''''
103157+ case 18446744073709545294LLU: // 99999998bN'''''''''''''''
103117103158 {
103118- state.addr = 18446744073709545300LLU; // 99999998bT'''''''''''''''
103159+ state.addr = 18446744073709545295LLU; // 99999998bO'''''''''''''''
103119103160 break;
103120103161 }
103121- case 18446744073709545300LLU: // 99999998bT'''''''''''''''
103162+ case 18446744073709545295LLU: // 99999998bO'''''''''''''''
103122103163 {
103123103164 {
103124103165 uint64_t arg = 0LLU;
@@ -103145,7 +103186,7 @@
103145103186 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103146103187 }
103147103188 // ACCUMULATE ARGUMENTS - END
103148- uint64_t return_to = 18446744073709545297LLU;
103189+ uint64_t return_to = 18446744073709545292LLU;
103149103190 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103150103191 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103151103192 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103154,12 +103195,12 @@
103154103195 state.addr = 787446708198178816LLU; // printnr___
103155103196 break;
103156103197 }
103157- case 18446744073709545297LLU: // 99999998bQ'''''''''''''''
103198+ case 18446744073709545292LLU: // 99999998bL'''''''''''''''
103158103199 {
103159- state.addr = 18446744073709545298LLU; // 99999998bR'''''''''''''''
103200+ state.addr = 18446744073709545293LLU; // 99999998bM'''''''''''''''
103160103201 break;
103161103202 }
103162- case 18446744073709545298LLU: // 99999998bR'''''''''''''''
103203+ case 18446744073709545293LLU: // 99999998bM'''''''''''''''
103163103204 {
103164103205 fprintf(stdout, "%s", " + 1)");
103165103206 fprintf(stdout, "%s", "\n struct pair heapraw[");
@@ -103169,7 +103210,7 @@
103169103210 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103170103211 }
103171103212 // ACCUMULATE ARGUMENTS - END
103172- uint64_t return_to = 18446744073709545295LLU;
103213+ uint64_t return_to = 18446744073709545290LLU;
103173103214 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103174103215 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103175103216 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103178,12 +103219,12 @@
103178103219 state.addr = 787446708198178816LLU; // printnr___
103179103220 break;
103180103221 }
103181- case 18446744073709545295LLU: // 99999998bO'''''''''''''''
103222+ case 18446744073709545290LLU: // 99999998bJ'''''''''''''''
103182103223 {
103183- state.addr = 18446744073709545296LLU; // 99999998bP'''''''''''''''
103224+ state.addr = 18446744073709545291LLU; // 99999998bK'''''''''''''''
103184103225 break;
103185103226 }
103186- case 18446744073709545296LLU: // 99999998bP'''''''''''''''
103227+ case 18446744073709545291LLU: // 99999998bK'''''''''''''''
103187103228 {
103188103229 fprintf(stdout, "%s", " + 1];");
103189103230 fprintf(stdout, "%s", "\n struct all all = init(heapraw);");
@@ -103199,7 +103240,7 @@
103199103240 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103200103241 }
103201103242 // ACCUMULATE ARGUMENTS - END
103202- uint64_t return_to = 18446744073709545293LLU;
103243+ uint64_t return_to = 18446744073709545288LLU;
103203103244 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103204103245 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103205103246 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103208,12 +103249,12 @@
103208103249 state.addr = 536089416471863296LLU; // builtins__
103209103250 break;
103210103251 }
103211- case 18446744073709545293LLU: // 99999998bM'''''''''''''''
103252+ case 18446744073709545288LLU: // 99999998bH'''''''''''''''
103212103253 {
103213- state.addr = 18446744073709545294LLU; // 99999998bN'''''''''''''''
103254+ state.addr = 18446744073709545289LLU; // 99999998bI'''''''''''''''
103214103255 break;
103215103256 }
103216- case 18446744073709545294LLU: // 99999998bN'''''''''''''''
103257+ case 18446744073709545289LLU: // 99999998bI'''''''''''''''
103217103258 {
103218103259 {
103219103260 uint64_t arg = 0LLU;
@@ -103245,7 +103286,7 @@
103245103286 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103246103287 }
103247103288 // ACCUMULATE ARGUMENTS - END
103248- uint64_t return_to = 18446744073709545290LLU;
103289+ uint64_t return_to = 18446744073709545285LLU;
103249103290 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
103250103291 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103251103292 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103254,23 +103295,23 @@
103254103295 state.addr = 782701543537682560LLU; // parseprog_
103255103296 break;
103256103297 }
103257- case 18446744073709545290LLU: // 99999998bJ'''''''''''''''
103298+ case 18446744073709545285LLU: // 99999998bE'''''''''''''''
103258103299 {
103259- state.addr = 18446744073709545291LLU; // 99999998bK'''''''''''''''
103300+ state.addr = 18446744073709545286LLU; // 99999998bF'''''''''''''''
103260103301 break;
103261103302 }
103262- case 18446744073709545291LLU: // 99999998bK'''''''''''''''
103303+ case 18446744073709545286LLU: // 99999998bF'''''''''''''''
103263103304 {
103264103305 // variable list<block_____> blocklist_ goes out of scope
103265103306 // emitted destructur for type list<block_____>
103266- state.addr = 18446744073709545288LLU; // 99999998bH'''''''''''''''
103307+ state.addr = 18446744073709545283LLU; // 99999998bC'''''''''''''''
103267103308 break;
103268103309 }
103269- case 18446744073709545288LLU: // 99999998bH'''''''''''''''
103310+ case 18446744073709545283LLU: // 99999998bC'''''''''''''''
103270103311 {
103271103312 if(!*LOCAL_ACCESS(heap.data, 11LLU, 10LLU)/*list*/)
103272103313 {
103273- state.addr = 18446744073709545289LLU; // 99999998bI'''''''''''''''
103314+ state.addr = 18446744073709545284LLU; // 99999998bD'''''''''''''''
103274103315 break;
103275103316 }
103276103317 // temporary list-element
@@ -103284,7 +103325,7 @@
103284103325 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103285103326 }
103286103327 // ACCUMULATE ARGUMENTS - END
103287- uint64_t return_to = 18446744073709545287LLU;
103328+ uint64_t return_to = 18446744073709545282LLU;
103288103329 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103289103330 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103290103331 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103293,20 +103334,20 @@
103293103334 state.addr = 18446744073709551121LLU; // 999999992Q'''''''''''''''
103294103335 break;
103295103336 }
103296- case 18446744073709545287LLU: // 99999998bG'''''''''''''''
103337+ case 18446744073709545282LLU: // 99999998bB'''''''''''''''
103297103338 {
103298103339 // RELEASE temporary destructor-variable
103299103340 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12
103300- state.addr = 18446744073709545288LLU; // 99999998bH'''''''''''''''
103341+ state.addr = 18446744073709545283LLU; // 99999998bC'''''''''''''''
103301103342 break;
103302103343 }
103303- case 18446744073709545289LLU: // 99999998bI'''''''''''''''
103344+ case 18446744073709545284LLU: // 99999998bD'''''''''''''''
103304103345 {
103305103346 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference blocklist_ at 11
103306- state.addr = 18446744073709545292LLU; // 99999998bL'''''''''''''''
103347+ state.addr = 18446744073709545287LLU; // 99999998bG'''''''''''''''
103307103348 break;
103308103349 }
103309- case 18446744073709545292LLU: // 99999998bL'''''''''''''''
103350+ case 18446744073709545287LLU: // 99999998bG'''''''''''''''
103310103351 {
103311103352 {
103312103353 uint64_t arg = 0LLU;
@@ -103346,7 +103387,7 @@
103346103387 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103347103388 }
103348103389 // ACCUMULATE ARGUMENTS - END
103349- uint64_t return_to = 18446744073709545285LLU;
103390+ uint64_t return_to = 18446744073709545280LLU;
103350103391 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
103351103392 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103352103393 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103355,12 +103396,12 @@
103355103396 state.addr = 587881350213857280LLU; // emitinit__
103356103397 break;
103357103398 }
103358- case 18446744073709545285LLU: // 99999998bE'''''''''''''''
103399+ case 18446744073709545280LLU: // 99999998b_'''''''''''''''
103359103400 {
103360- state.addr = 18446744073709545286LLU; // 99999998bF'''''''''''''''
103401+ state.addr = 18446744073709545281LLU; // 99999998bA'''''''''''''''
103361103402 break;
103362103403 }
103363- case 18446744073709545286LLU: // 99999998bF'''''''''''''''
103404+ case 18446744073709545281LLU: // 99999998bA'''''''''''''''
103364103405 {
103365103406 // ACCUMULATE ARGUMENTS - BEGIN
103366103407 {
@@ -103368,7 +103409,7 @@
103368103409 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103369103410 }
103370103411 // ACCUMULATE ARGUMENTS - END
103371- uint64_t return_to = 18446744073709545283LLU;
103412+ uint64_t return_to = 18446744073709545278LLU;
103372103413 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103373103414 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103374103415 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103377,12 +103418,12 @@
103377103418 state.addr = 587881345921715008LLU; // emitenter_
103378103419 break;
103379103420 }
103380- case 18446744073709545283LLU: // 99999998bC'''''''''''''''
103421+ case 18446744073709545278LLU: // 99999998a8'''''''''''''''
103381103422 {
103382- state.addr = 18446744073709545284LLU; // 99999998bD'''''''''''''''
103423+ state.addr = 18446744073709545279LLU; // 99999998a9'''''''''''''''
103383103424 break;
103384103425 }
103385- case 18446744073709545284LLU: // 99999998bD'''''''''''''''
103426+ case 18446744073709545279LLU: // 99999998a9'''''''''''''''
103386103427 {
103387103428 fprintf(stdout, "%s", "\n // program starts here with call into main");
103388103429 {
@@ -103423,7 +103464,7 @@
103423103464 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103424103465 }
103425103466 // ACCUMULATE ARGUMENTS - END
103426- uint64_t return_to = 18446744073709545280LLU;
103467+ uint64_t return_to = 18446744073709545275LLU;
103427103468 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
103428103469 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103429103470 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103432,12 +103473,12 @@
103432103473 state.addr = 548487490190330432LLU; // callbegin_
103433103474 break;
103434103475 }
103435- case 18446744073709545280LLU: // 99999998b_'''''''''''''''
103476+ case 18446744073709545275LLU: // 99999998a5'''''''''''''''
103436103477 {
103437- state.addr = 18446744073709545281LLU; // 99999998bA'''''''''''''''
103478+ state.addr = 18446744073709545276LLU; // 99999998a6'''''''''''''''
103438103479 break;
103439103480 }
103440- case 18446744073709545281LLU: // 99999998bA'''''''''''''''
103481+ case 18446744073709545276LLU: // 99999998a6'''''''''''''''
103441103482 {
103442103483 {
103443103484 uint64_t arg = 0LLU;
@@ -103469,7 +103510,7 @@
103469103510 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103470103511 }
103471103512 // ACCUMULATE ARGUMENTS - END
103472- uint64_t return_to = 18446744073709545278LLU;
103513+ uint64_t return_to = 18446744073709545273LLU;
103473103514 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
103474103515 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103475103516 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103478,12 +103519,12 @@
103478103519 state.addr = 517221173180428288LLU; // argconst__
103479103520 break;
103480103521 }
103481- case 18446744073709545278LLU: // 99999998a8'''''''''''''''
103522+ case 18446744073709545273LLU: // 99999998a3'''''''''''''''
103482103523 {
103483- state.addr = 18446744073709545279LLU; // 99999998a9'''''''''''''''
103524+ state.addr = 18446744073709545274LLU; // 99999998a4'''''''''''''''
103484103525 break;
103485103526 }
103486- case 18446744073709545279LLU: // 99999998a9'''''''''''''''
103527+ case 18446744073709545274LLU: // 99999998a4'''''''''''''''
103487103528 {
103488103529 // ACCUMULATE ARGUMENTS - BEGIN
103489103530 {
@@ -103507,7 +103548,7 @@
103507103548 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103508103549 }
103509103550 // ACCUMULATE ARGUMENTS - END
103510- uint64_t return_to = 18446744073709545276LLU;
103551+ uint64_t return_to = 18446744073709545271LLU;
103511103552 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
103512103553 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103513103554 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103516,12 +103557,12 @@
103516103557 state.addr = 548487493561614336LLU; // callend___
103517103558 break;
103518103559 }
103519- case 18446744073709545276LLU: // 99999998a6'''''''''''''''
103560+ case 18446744073709545271LLU: // 99999998a1'''''''''''''''
103520103561 {
103521- state.addr = 18446744073709545277LLU; // 99999998a7'''''''''''''''
103562+ state.addr = 18446744073709545272LLU; // 99999998a2'''''''''''''''
103522103563 break;
103523103564 }
103524- case 18446744073709545277LLU: // 99999998a7'''''''''''''''
103565+ case 18446744073709545272LLU: // 99999998a2'''''''''''''''
103525103566 {
103526103567 fprintf(stdout, "%s", "\n fprintf(stderr, \"INTERNAL ERROR: 0-instruction-address\\n\"); // this should never be reached");
103527103568 fprintf(stdout, "%s", "\n exit(-1);");
@@ -103548,7 +103589,7 @@
103548103589 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103549103590 }
103550103591 // ACCUMULATE ARGUMENTS - END
103551- uint64_t return_to = 18446744073709545273LLU;
103592+ uint64_t return_to = 18446744073709545268LLU;
103552103593 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
103553103594 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103554103595 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103557,20 +103598,20 @@
103557103598 state.addr = 587881357748664875LLU; // emitpoptmp
103558103599 break;
103559103600 }
103560- case 18446744073709545273LLU: // 99999998a3'''''''''''''''
103601+ case 18446744073709545268LLU: // 99999998ay'''''''''''''''
103561103602 {
103562- state.addr = 18446744073709545274LLU; // 99999998a4'''''''''''''''
103603+ state.addr = 18446744073709545269LLU; // 99999998az'''''''''''''''
103563103604 break;
103564103605 }
103565- case 18446744073709545274LLU: // 99999998a4'''''''''''''''
103606+ case 18446744073709545269LLU: // 99999998az'''''''''''''''
103566103607 {
103567103608 // variable u64 level_____ goes out of scope
103568103609 // emitted destructur for type u64
103569103610 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 20
103570- state.addr = 18446744073709545275LLU; // 99999998a5'''''''''''''''
103611+ state.addr = 18446744073709545270LLU; // 99999998a0'''''''''''''''
103571103612 break;
103572103613 }
103573- case 18446744073709545275LLU: // 99999998a5'''''''''''''''
103614+ case 18446744073709545270LLU: // 99999998a0'''''''''''''''
103574103615 {
103575103616 // ACCUMULATE ARGUMENTS - BEGIN
103576103617 {
@@ -103586,7 +103627,7 @@
103586103627 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103587103628 }
103588103629 // ACCUMULATE ARGUMENTS - END
103589- uint64_t return_to = 18446744073709545271LLU;
103630+ uint64_t return_to = 18446744073709545266LLU;
103590103631 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
103591103632 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103592103633 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103595,12 +103636,12 @@
103595103636 state.addr = 587881353282000896LLU; // emitleave_
103596103637 break;
103597103638 }
103598- case 18446744073709545271LLU: // 99999998a1'''''''''''''''
103639+ case 18446744073709545266LLU: // 99999998aw'''''''''''''''
103599103640 {
103600- state.addr = 18446744073709545272LLU; // 99999998a2'''''''''''''''
103641+ state.addr = 18446744073709545267LLU; // 99999998ax'''''''''''''''
103601103642 break;
103602103643 }
103603- case 18446744073709545272LLU: // 99999998a2'''''''''''''''
103644+ case 18446744073709545267LLU: // 99999998ax'''''''''''''''
103604103645 {
103605103646 // variable u64 resultaddr goes out of scope
103606103647 // emitted destructur for type u64
@@ -103620,10 +103661,10 @@
103620103661 // variable u64 outside___ goes out of scope
103621103662 // emitted destructur for type u64
103622103663 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference outside___ at 14
103623- state.addr = 18446744073709545282LLU; // 99999998bB'''''''''''''''
103664+ state.addr = 18446744073709545277LLU; // 99999998a7'''''''''''''''
103624103665 break;
103625103666 }
103626- case 18446744073709545282LLU: // 99999998bB'''''''''''''''
103667+ case 18446744073709545277LLU: // 99999998a7'''''''''''''''
103627103668 {
103628103669 fprintf(stdout, "%s", "\n default:");
103629103670 fprintf(stdout, "%s", "\n {");
@@ -103637,10 +103678,10 @@
103637103678 fprintf(stdout, "%s", "\n");
103638103679 fprintf(stdout, "%s", "\n uint64_t main_result = heap.data[0].elem0;");
103639103680 fprintf(stdout, "%s", "\n");
103640- state.addr = 18446744073709545270LLU; // 99999998a0'''''''''''''''
103681+ state.addr = 18446744073709545265LLU; // 99999998av'''''''''''''''
103641103682 break;
103642103683 }
103643- case 18446744073709545270LLU: // 99999998a0'''''''''''''''
103684+ case 18446744073709545265LLU: // 99999998av'''''''''''''''
103644103685 {
103645103686 // ACCUMULATE ARGUMENTS - BEGIN
103646103687 {
@@ -103648,7 +103689,7 @@
103648103689 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103649103690 }
103650103691 // ACCUMULATE ARGUMENTS - END
103651- uint64_t return_to = 18446744073709545268LLU;
103692+ uint64_t return_to = 18446744073709545263LLU;
103652103693 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103653103694 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103654103695 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103657,12 +103698,12 @@
103657103698 state.addr = 891913148528723755LLU; // verifyheap
103658103699 break;
103659103700 }
103660- case 18446744073709545268LLU: // 99999998ay'''''''''''''''
103701+ case 18446744073709545263LLU: // 99999998at'''''''''''''''
103661103702 {
103662- state.addr = 18446744073709545269LLU; // 99999998az'''''''''''''''
103703+ state.addr = 18446744073709545264LLU; // 99999998au'''''''''''''''
103663103704 break;
103664103705 }
103665- case 18446744073709545269LLU: // 99999998az'''''''''''''''
103706+ case 18446744073709545264LLU: // 99999998au'''''''''''''''
103666103707 {
103667103708 fprintf(stdout, "%s", "\n if(heap.availilable_size_for_dynamic_objects != ");
103668103709 fprintf(stdout, "%llu", (unsigned long long)/*heapsize__*/*LOCAL_ACCESS(heap.data, 13LLU, 3LLU));
@@ -103691,7 +103732,7 @@
103691103732 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103692103733 }
103693103734 // ACCUMULATE ARGUMENTS - END
103694- uint64_t return_to = 18446744073709545266LLU;
103735+ uint64_t return_to = 18446744073709545261LLU;
103695103736 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
103696103737 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103697103738 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103700,12 +103741,12 @@
103700103741 state.addr = 587881350213860864LLU; // emitinit2_
103701103742 break;
103702103743 }
103703- case 18446744073709545266LLU: // 99999998aw'''''''''''''''
103744+ case 18446744073709545261LLU: // 99999998ar'''''''''''''''
103704103745 {
103705- state.addr = 18446744073709545267LLU; // 99999998ax'''''''''''''''
103746+ state.addr = 18446744073709545262LLU; // 99999998as'''''''''''''''
103706103747 break;
103707103748 }
103708- case 18446744073709545267LLU: // 99999998ax'''''''''''''''
103749+ case 18446744073709545262LLU: // 99999998as'''''''''''''''
103709103750 {
103710103751 fprintf(stdout, "%s", "\n");
103711103752 {
@@ -103726,7 +103767,7 @@
103726103767 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103727103768 }
103728103769 // ACCUMULATE ARGUMENTS - END
103729- uint64_t return_to = 18446744073709545263LLU;
103770+ uint64_t return_to = 18446744073709545258LLU;
103730103771 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
103731103772 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103732103773 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103735,12 +103776,12 @@
103735103776 state.addr = 819847183514601582LLU; // reportdefs
103736103777 break;
103737103778 }
103738- case 18446744073709545263LLU: // 99999998at'''''''''''''''
103779+ case 18446744073709545258LLU: // 99999998ao'''''''''''''''
103739103780 {
103740- state.addr = 18446744073709545264LLU; // 99999998au'''''''''''''''
103781+ state.addr = 18446744073709545259LLU; // 99999998ap'''''''''''''''
103741103782 break;
103742103783 }
103743- case 18446744073709545264LLU: // 99999998au'''''''''''''''
103784+ case 18446744073709545259LLU: // 99999998ap'''''''''''''''
103744103785 {
103745103786 list_size(heap.data, /*fndefs____*/*LOCAL_ACCESS(heap.data, 15LLU, 8LLU), &/*nr________*/*LOCAL_ACCESS(heap.data, 15LLU, 13LLU));
103746103787 // ACCUMULATE ARGUMENTS - BEGIN
@@ -103749,7 +103790,7 @@
103749103790 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103750103791 }
103751103792 // ACCUMULATE ARGUMENTS - END
103752- uint64_t return_to = 18446744073709545261LLU;
103793+ uint64_t return_to = 18446744073709545256LLU;
103753103794 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103754103795 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103755103796 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103758,12 +103799,12 @@
103758103799 state.addr = 819847183517274112LLU; // reportnr__
103759103800 break;
103760103801 }
103761- case 18446744073709545261LLU: // 99999998ar'''''''''''''''
103802+ case 18446744073709545256LLU: // 99999998am'''''''''''''''
103762103803 {
103763- state.addr = 18446744073709545262LLU; // 99999998as'''''''''''''''
103804+ state.addr = 18446744073709545257LLU; // 99999998an'''''''''''''''
103764103805 break;
103765103806 }
103766- case 18446744073709545262LLU: // 99999998as'''''''''''''''
103807+ case 18446744073709545257LLU: // 99999998an'''''''''''''''
103767103808 {
103768103809 fprintf(stderr, "%s", " procedure-/function-definitions\n");
103769103810 // ACCUMULATE ARGUMENTS - BEGIN
@@ -103776,7 +103817,7 @@
103776103817 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103777103818 }
103778103819 // ACCUMULATE ARGUMENTS - END
103779- uint64_t return_to = 18446744073709545259LLU;
103820+ uint64_t return_to = 18446744073709545254LLU;
103780103821 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
103781103822 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103782103823 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103785,12 +103826,12 @@
103785103826 state.addr = 819847183518878446LLU; // reporttyps
103786103827 break;
103787103828 }
103788- case 18446744073709545259LLU: // 99999998ap'''''''''''''''
103829+ case 18446744073709545254LLU: // 99999998ak'''''''''''''''
103789103830 {
103790- state.addr = 18446744073709545260LLU; // 99999998aq'''''''''''''''
103831+ state.addr = 18446744073709545255LLU; // 99999998al'''''''''''''''
103791103832 break;
103792103833 }
103793- case 18446744073709545260LLU: // 99999998aq'''''''''''''''
103834+ case 18446744073709545255LLU: // 99999998al'''''''''''''''
103794103835 {
103795103836 list_size(heap.data, /*typedefs__*/*LOCAL_ACCESS(heap.data, 15LLU, 9LLU), &/*nr________*/*LOCAL_ACCESS(heap.data, 15LLU, 13LLU));
103796103837 // ACCUMULATE ARGUMENTS - BEGIN
@@ -103799,7 +103840,7 @@
103799103840 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103800103841 }
103801103842 // ACCUMULATE ARGUMENTS - END
103802- uint64_t return_to = 18446744073709545257LLU;
103843+ uint64_t return_to = 18446744073709545252LLU;
103803103844 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103804103845 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103805103846 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103808,12 +103849,12 @@
103808103849 state.addr = 819847183517274112LLU; // reportnr__
103809103850 break;
103810103851 }
103811- case 18446744073709545257LLU: // 99999998an'''''''''''''''
103852+ case 18446744073709545252LLU: // 99999998ai'''''''''''''''
103812103853 {
103813- state.addr = 18446744073709545258LLU; // 99999998ao'''''''''''''''
103854+ state.addr = 18446744073709545253LLU; // 99999998aj'''''''''''''''
103814103855 break;
103815103856 }
103816- case 18446744073709545258LLU: // 99999998ao'''''''''''''''
103857+ case 18446744073709545253LLU: // 99999998aj'''''''''''''''
103817103858 {
103818103859 fprintf(stderr, "%s", " type-definitions\n");
103819103860 // variable u64 def_id____ goes out of scope
@@ -103822,10 +103863,10 @@
103822103863 // variable u64 nr________ goes out of scope
103823103864 // emitted destructur for type u64
103824103865 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 14
103825- state.addr = 18446744073709545265LLU; // 99999998av'''''''''''''''
103866+ state.addr = 18446744073709545260LLU; // 99999998aq'''''''''''''''
103826103867 break;
103827103868 }
103828- case 18446744073709545265LLU: // 99999998av'''''''''''''''
103869+ case 18446744073709545260LLU: // 99999998aq'''''''''''''''
103829103870 {
103830103871 fprintf(stderr, "%s", "done\n");
103831103872 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 0LLU)) = 0LLU;
@@ -103841,14 +103882,14 @@
103841103882 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mainacount at 11
103842103883 // variable list<typedef___> typedefs__ goes out of scope
103843103884 // emitted destructur for type list<typedef___>
103844- state.addr = 18446744073709545255LLU; // 99999998al'''''''''''''''
103885+ state.addr = 18446744073709545250LLU; // 99999998ag'''''''''''''''
103845103886 break;
103846103887 }
103847- case 18446744073709545255LLU: // 99999998al'''''''''''''''
103888+ case 18446744073709545250LLU: // 99999998ag'''''''''''''''
103848103889 {
103849103890 if(!*LOCAL_ACCESS(heap.data, 10LLU, 9LLU)/*list*/)
103850103891 {
103851- state.addr = 18446744073709545256LLU; // 99999998am'''''''''''''''
103892+ state.addr = 18446744073709545251LLU; // 99999998ah'''''''''''''''
103852103893 break;
103853103894 }
103854103895 // temporary list-element
@@ -103862,7 +103903,7 @@
103862103903 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103863103904 }
103864103905 // ACCUMULATE ARGUMENTS - END
103865- uint64_t return_to = 18446744073709545254LLU;
103906+ uint64_t return_to = 18446744073709545249LLU;
103866103907 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103867103908 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103868103909 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103871,26 +103912,26 @@
103871103912 state.addr = 18446744073709551111LLU; // 999999992G'''''''''''''''
103872103913 break;
103873103914 }
103874- case 18446744073709545254LLU: // 99999998ak'''''''''''''''
103915+ case 18446744073709545249LLU: // 99999998af'''''''''''''''
103875103916 {
103876103917 // RELEASE temporary destructor-variable
103877103918 (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
103878- state.addr = 18446744073709545255LLU; // 99999998al'''''''''''''''
103919+ state.addr = 18446744073709545250LLU; // 99999998ag'''''''''''''''
103879103920 break;
103880103921 }
103881- case 18446744073709545256LLU: // 99999998am'''''''''''''''
103922+ case 18446744073709545251LLU: // 99999998ah'''''''''''''''
103882103923 {
103883103924 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 10
103884103925 // variable list<defidfn___> fndefs____ goes out of scope
103885103926 // emitted destructur for type list<defidfn___>
103886- state.addr = 18446744073709545252LLU; // 99999998ai'''''''''''''''
103927+ state.addr = 18446744073709545247LLU; // 99999998ad'''''''''''''''
103887103928 break;
103888103929 }
103889- case 18446744073709545252LLU: // 99999998ai'''''''''''''''
103930+ case 18446744073709545247LLU: // 99999998ad'''''''''''''''
103890103931 {
103891103932 if(!*LOCAL_ACCESS(heap.data, 9LLU, 8LLU)/*list*/)
103892103933 {
103893- state.addr = 18446744073709545253LLU; // 99999998aj'''''''''''''''
103934+ state.addr = 18446744073709545248LLU; // 99999998ae'''''''''''''''
103894103935 break;
103895103936 }
103896103937 // temporary list-element
@@ -103904,7 +103945,7 @@
103904103945 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103905103946 }
103906103947 // ACCUMULATE ARGUMENTS - END
103907- uint64_t return_to = 18446744073709545251LLU;
103948+ uint64_t return_to = 18446744073709545246LLU;
103908103949 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103909103950 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103910103951 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103913,26 +103954,26 @@
103913103954 state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
103914103955 break;
103915103956 }
103916- case 18446744073709545251LLU: // 99999998ah'''''''''''''''
103957+ case 18446744073709545246LLU: // 99999998ac'''''''''''''''
103917103958 {
103918103959 // RELEASE temporary destructor-variable
103919103960 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10
103920- state.addr = 18446744073709545252LLU; // 99999998ai'''''''''''''''
103961+ state.addr = 18446744073709545247LLU; // 99999998ad'''''''''''''''
103921103962 break;
103922103963 }
103923- case 18446744073709545253LLU: // 99999998aj'''''''''''''''
103964+ case 18446744073709545248LLU: // 99999998ae'''''''''''''''
103924103965 {
103925103966 (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fndefs____ at 9
103926103967 // variable list<nametoaddr> translate_ goes out of scope
103927103968 // emitted destructur for type list<nametoaddr>
103928- state.addr = 18446744073709545249LLU; // 99999998af'''''''''''''''
103969+ state.addr = 18446744073709545244LLU; // 99999998aa'''''''''''''''
103929103970 break;
103930103971 }
103931- case 18446744073709545249LLU: // 99999998af'''''''''''''''
103972+ case 18446744073709545244LLU: // 99999998aa'''''''''''''''
103932103973 {
103933103974 if(!*LOCAL_ACCESS(heap.data, 8LLU, 7LLU)/*list*/)
103934103975 {
103935- state.addr = 18446744073709545250LLU; // 99999998ag'''''''''''''''
103976+ state.addr = 18446744073709545245LLU; // 99999998ab'''''''''''''''
103936103977 break;
103937103978 }
103938103979 // temporary list-element
@@ -103946,7 +103987,7 @@
103946103987 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
103947103988 }
103948103989 // ACCUMULATE ARGUMENTS - END
103949- uint64_t return_to = 18446744073709545248LLU;
103990+ uint64_t return_to = 18446744073709545243LLU;
103950103991 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
103951103992 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
103952103993 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -103955,14 +103996,14 @@
103955103996 state.addr = 18446744073709551351LLU; // 9999999951'''''''''''''''
103956103997 break;
103957103998 }
103958- case 18446744073709545248LLU: // 99999998ae'''''''''''''''
103999+ case 18446744073709545243LLU: // 99999998a$'''''''''''''''
103959104000 {
103960104001 // RELEASE temporary destructor-variable
103961104002 (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9
103962- state.addr = 18446744073709545249LLU; // 99999998af'''''''''''''''
104003+ state.addr = 18446744073709545244LLU; // 99999998aa'''''''''''''''
103963104004 break;
103964104005 }
103965- case 18446744073709545250LLU: // 99999998ag'''''''''''''''
104006+ case 18446744073709545245LLU: // 99999998ab'''''''''''''''
103966104007 {
103967104008 (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference translate_ at 8
103968104009 // variable u64 end_______ goes out of scope
Show on old repository browser