• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision998 (tree)
Time2020-04-30 07:08:56
Authorjakobthomsen

Log Message

use returning list

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (revision 997)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (revision 998)
@@ -5699,40 +5699,44 @@
56995699 case 782700512577972928LLU: // pardefscp_
57005700 {
57015701 {
5702- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
5702+ uint64_t arg = 0;
57035703 LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
57045704 }
57055705 {
5706- uint64_t arg = 0;
5706+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
57075707 LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
57085708 }
5709+ {
5710+ uint64_t arg = 0;
5711+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5712+ }
57095713 state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''
57105714 break;
57115715 }
57125716 case 18446744073709551418LLU: // 9999999964'''''''''''''''
57135717 {
5714- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
5718+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
57155719 {
5720+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
57165721 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5717- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
57185722 {
57195723 state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
57205724 break;
57215725 }
57225726 }
5723- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
5724- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
5727+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5728+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
57255729 {
57265730 uint64_t arg = 0;
5727- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5731+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
57285732 }
57295733 // ACCUMULATE ARGUMENTS - BEGIN
57305734 {
5731- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
5735+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
57325736 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
57335737 }
57345738 {
5735- uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
5739+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
57365740 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
57375741 }
57385742 // ACCUMULATE ARGUMENTS - END
@@ -5747,7 +5751,7 @@
57475751 }
57485752 case 18446744073709551413LLU: // 999999996z'''''''''''''''
57495753 {
5750- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 11) ? 18446744073709551416LLU : 18446744073709551415LLU;
5754+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551416LLU : 18446744073709551415LLU;
57515755 break;
57525756 }
57535757 case 18446744073709551416LLU: // 9999999962'''''''''''''''
@@ -5759,7 +5763,7 @@
57595763 // emitted destructur for type pardef____
57605764 // ACCUMULATE ARGUMENTS - BEGIN
57615765 {
5762- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
5766+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
57635767 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
57645768 }
57655769 // ACCUMULATE ARGUMENTS - END
@@ -5785,7 +5789,7 @@
57855789 }
57865790 case 18446744073709551414LLU: // 9999999960'''''''''''''''
57875791 {
5788- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5792+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
57895793 // parameter-reference pardef____ src_______ goes out of scope
57905794 // parameter-reference list<pardef____> srcs______ goes out of scope
57915795 state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''
@@ -5793,10 +5797,13 @@
57935797 }
57945798 case 18446744073709551417LLU: // 9999999963'''''''''''''''
57955799 {
5800+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
5801+ // variable list<pardef____> dsts______ goes out of scope
5802+ // (uninitialized -> no destructor-call)
5803+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
57965804 // parameter-reference list<pardef____> srcs______ goes out of scope
57975805 (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5798- // parameter-reference list<pardef____> dsts______ goes out of scope
5799- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
5806+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
58005807 {
58015808 uint64_t baseinfo = heap.data[0].elem1;
58025809 struct pair pair = unpair(&heap, &baseinfo);
@@ -5808,50 +5815,54 @@
58085815 case 587581813005601646LLU: // elems2pars
58095816 {
58105817 {
5811- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
5818+ uint64_t arg = 0;
58125819 LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58135820 }
58145821 {
5815- uint64_t arg = 0;
5822+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
58165823 LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58175824 }
5825+ {
5826+ uint64_t arg = 0;
5827+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5828+ }
58185829 state.addr = 18446744073709551411LLU; // 999999996x'''''''''''''''
58195830 break;
58205831 }
58215832 case 18446744073709551411LLU: // 999999996x'''''''''''''''
58225833 {
5823- if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5834+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
58245835 {
5836+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
58255837 (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5826- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
58275838 {
58285839 state.addr = 18446744073709551410LLU; // 999999996w'''''''''''''''
58295840 break;
58305841 }
58315842 }
5832- /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5833- *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5843+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
5844+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
58345845 {
58355846 uint64_t arg = 0;
5836- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5847+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58375848 }
5838- *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = 1;
5849+ *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = 1;
58395850 {
58405851 uint64_t arg = 0;
5841- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5852+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58425853 }
5843- *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*reference_*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
5854+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*reference_*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
58445855 {
58455856 uint64_t arg = 0;
5846- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5857+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58475858 }
58485859 // ACCUMULATE ARGUMENTS - BEGIN
58495860 {
5850- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5861+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
58515862 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58525863 }
58535864 {
5854- uint64_t arg = /*src_______*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 1LLU);
5865+ uint64_t arg = /*src_______*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 1LLU);
58555866 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58565867 }
58575868 // ACCUMULATE ARGUMENTS - END
@@ -5868,11 +5879,11 @@
58685879 {
58695880 {
58705881 uint64_t arg = 0;
5871- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5882+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58725883 }
58735884 // ACCUMULATE ARGUMENTS - BEGIN
58745885 {
5875- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
5886+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
58765887 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58775888 }
58785889 // ACCUMULATE ARGUMENTS - END
@@ -5889,27 +5900,27 @@
58895900 {
58905901 {
58915902 uint64_t arg = 0;
5892- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5903+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58935904 }
58945905 // ACCUMULATE ARGUMENTS - BEGIN
58955906 {
5896- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
5907+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
58975908 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58985909 }
58995910 {
5900- uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
5911+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 11LLU, 8LLU);
59015912 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59025913 }
59035914 {
5904- uint64_t arg = /*mutable___*/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
5915+ uint64_t arg = /*mutable___*/*LOCAL_ACCESS(heap.data, 11LLU, 6LLU);
59055916 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59065917 }
59075918 {
5908- uint64_t arg = /*continuity*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
5919+ uint64_t arg = /*continuity*/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
59095920 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59105921 }
59115922 {
5912- uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
5923+ uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 11LLU, 7LLU);
59135924 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59145925 }
59155926 // ACCUMULATE ARGUMENTS - END
@@ -5924,7 +5935,7 @@
59245935 }
59255936 case 18446744073709551404LLU: // 999999996q'''''''''''''''
59265937 {
5927- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)), 11) ? 18446744073709551407LLU : 18446744073709551406LLU;
5938+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &*LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551407LLU : 18446744073709551406LLU;
59285939 break;
59295940 }
59305941 case 18446744073709551407LLU: // 999999996t'''''''''''''''
@@ -5932,7 +5943,7 @@
59325943 fprintf(stderr, "%s", "pushing par ");
59335944 // ACCUMULATE ARGUMENTS - BEGIN
59345945 {
5935- uint64_t arg = /*newpar____*/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU), 0LLU);
5946+ uint64_t arg = /*newpar____*/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU), 0LLU);
59365947 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59375948 }
59385949 // ACCUMULATE ARGUMENTS - END
@@ -5955,7 +5966,7 @@
59555966 // emitted destructur for type pardef____
59565967 // ACCUMULATE ARGUMENTS - BEGIN
59575968 {
5958- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
5969+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
59595970 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59605971 }
59615972 // ACCUMULATE ARGUMENTS - END
@@ -5981,19 +5992,19 @@
59815992 }
59825993 case 18446744073709551405LLU: // 999999996r'''''''''''''''
59835994 {
5984- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10
5995+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
59855996 // variable continuity continuity goes out of scope
59865997 // (uninitialized -> no destructor-call)
5987- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 9
5998+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 10
59885999 // variable type______ type______ goes out of scope
59896000 // (uninitialized -> no destructor-call)
5990- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 8
6001+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 9
59916002 // variable u64 reference_ goes out of scope
59926003 // (uninitialized -> no destructor-call)
5993- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 7
6004+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 8
59946005 // variable u64 mutable___ goes out of scope
59956006 // (uninitialized -> no destructor-call)
5996- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 6
6007+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 7
59976008 // parameter-reference elemdef___ src_______ goes out of scope
59986009 // parameter-reference list<elemdef___> srcs______ goes out of scope
59996010 state.addr = 18446744073709551411LLU; // 999999996x'''''''''''''''
@@ -6001,12 +6012,15 @@
60016012 }
60026013 case 18446744073709551410LLU: // 999999996w'''''''''''''''
60036014 {
6015+ swap(&*LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
6016+ // variable list<pardef____> dsts______ goes out of scope
6017+ // (uninitialized -> no destructor-call)
6018+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 4
60046019 // parameter u64 reference_ goes out of scope
60056020 (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 3
60066021 // parameter-reference list<elemdef___> srcs______ goes out of scope
60076022 (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6008- // parameter-reference list<pardef____> dsts______ goes out of scope
6009- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
6023+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
60106024 {
60116025 uint64_t baseinfo = heap.data[0].elem1;
60126026 struct pair pair = unpair(&heap, &baseinfo);
@@ -6136,40 +6150,44 @@
61366150 case 587581796494272427LLU: // elemdefscp
61376151 {
61386152 {
6139- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
6153+ uint64_t arg = 0;
61406154 LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
61416155 }
61426156 {
6143- uint64_t arg = 0;
6157+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
61446158 LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
61456159 }
6160+ {
6161+ uint64_t arg = 0;
6162+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6163+ }
61466164 state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
61476165 break;
61486166 }
61496167 case 18446744073709551397LLU: // 999999996j'''''''''''''''
61506168 {
6151- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
6169+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
61526170 {
6171+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
61536172 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
6154- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
61556173 {
61566174 state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
61576175 break;
61586176 }
61596177 }
6160- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
6161- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
6178+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
6179+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
61626180 {
61636181 uint64_t arg = 0;
6164- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6182+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
61656183 }
61666184 // ACCUMULATE ARGUMENTS - BEGIN
61676185 {
6168- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6186+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
61696187 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
61706188 }
61716189 {
6172- uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
6190+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
61736191 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
61746192 }
61756193 // ACCUMULATE ARGUMENTS - END
@@ -6184,7 +6202,7 @@
61846202 }
61856203 case 18446744073709551392LLU: // 999999996e'''''''''''''''
61866204 {
6187- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 7) ? 18446744073709551395LLU : 18446744073709551394LLU;
6205+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551395LLU : 18446744073709551394LLU;
61886206 break;
61896207 }
61906208 case 18446744073709551395LLU: // 999999996h'''''''''''''''
@@ -6192,7 +6210,7 @@
61926210 fprintf(stderr, "%s", "pushing par ");
61936211 // ACCUMULATE ARGUMENTS - BEGIN
61946212 {
6195- uint64_t arg = /*dst_______*/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU), 1LLU);
6213+ uint64_t arg = /*dst_______*/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU), 1LLU);
61966214 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
61976215 }
61986216 // ACCUMULATE ARGUMENTS - END
@@ -6215,7 +6233,7 @@
62156233 // emitted destructur for type elemdef___
62166234 // ACCUMULATE ARGUMENTS - BEGIN
62176235 {
6218- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6236+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
62196237 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
62206238 }
62216239 // ACCUMULATE ARGUMENTS - END
@@ -6241,7 +6259,7 @@
62416259 }
62426260 case 18446744073709551393LLU: // 999999996f'''''''''''''''
62436261 {
6244- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
6262+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
62456263 // parameter-reference elemdef___ src_______ goes out of scope
62466264 // parameter-reference list<elemdef___> srcs______ goes out of scope
62476265 state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
@@ -6249,10 +6267,13 @@
62496267 }
62506268 case 18446744073709551396LLU: // 999999996i'''''''''''''''
62516269 {
6270+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
6271+ // variable list<elemdef___> dsts______ goes out of scope
6272+ // (uninitialized -> no destructor-call)
6273+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
62526274 // parameter-reference list<elemdef___> srcs______ goes out of scope
62536275 (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6254- // parameter-reference list<elemdef___> dsts______ goes out of scope
6255- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
6276+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
62566277 {
62576278 uint64_t baseinfo = heap.data[0].elem1;
62586279 struct pair pair = unpair(&heap, &baseinfo);
@@ -9569,40 +9590,44 @@
95699590 case 552446646814171136LLU: // copyvars__
95709591 {
95719592 {
9572- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
9593+ uint64_t arg = 0;
95739594 LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
95749595 }
95759596 {
9576- uint64_t arg = 0;
9597+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
95779598 LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
95789599 }
9600+ {
9601+ uint64_t arg = 0;
9602+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9603+ }
95799604 state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
95809605 break;
95819606 }
95829607 case 18446744073709551207LLU: // 999999993l'''''''''''''''
95839608 {
9584- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
9609+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
95859610 {
9611+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
95869612 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
9587- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
95889613 {
95899614 state.addr = 18446744073709551206LLU; // 999999993k'''''''''''''''
95909615 break;
95919616 }
95929617 }
9593- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
9594- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
9618+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
9619+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
95959620 {
95969621 uint64_t arg = 0;
9597- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
9622+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
95989623 }
95999624 // ACCUMULATE ARGUMENTS - BEGIN
96009625 {
9601- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
9626+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
96029627 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
96039628 }
96049629 {
9605- uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
9630+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
96069631 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
96079632 }
96089633 // ACCUMULATE ARGUMENTS - END
@@ -9617,7 +9642,7 @@
96179642 }
96189643 case 18446744073709551202LLU: // 999999993g'''''''''''''''
96199644 {
9620- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 4) ? 18446744073709551205LLU : 18446744073709551204LLU;
9645+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551205LLU : 18446744073709551204LLU;
96219646 break;
96229647 }
96239648 case 18446744073709551205LLU: // 999999993j'''''''''''''''
@@ -9629,7 +9654,7 @@
96299654 // emitted destructur for type variant___
96309655 // ACCUMULATE ARGUMENTS - BEGIN
96319656 {
9632- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
9657+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
96339658 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
96349659 }
96359660 // ACCUMULATE ARGUMENTS - END
@@ -9655,7 +9680,7 @@
96559680 }
96569681 case 18446744073709551203LLU: // 999999993h'''''''''''''''
96579682 {
9658- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
9683+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
96599684 // parameter-reference variant___ src_______ goes out of scope
96609685 // parameter-reference list<variant___> srcs______ goes out of scope
96619686 state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
@@ -9663,10 +9688,13 @@
96639688 }
96649689 case 18446744073709551206LLU: // 999999993k'''''''''''''''
96659690 {
9691+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
9692+ // variable list<variant___> dsts______ goes out of scope
9693+ // (uninitialized -> no destructor-call)
9694+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
96669695 // parameter-reference list<variant___> srcs______ goes out of scope
96679696 (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
9668- // parameter-reference list<variant___> dsts______ goes out of scope
9669- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
9697+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
96709698 {
96719699 uint64_t baseinfo = heap.data[0].elem1;
96729700 struct pair pair = unpair(&heap, &baseinfo);
@@ -44478,17 +44506,34 @@
4447844506 uint64_t arg = 0;
4447944507 LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4448044508 }
44509+ {
44510+ uint64_t arg = 0;
44511+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44512+ }
4448144513 // ACCUMULATE ARGUMENTS - BEGIN
4448244514 {
44483- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
44515+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
4448444516 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4448544517 }
44518+ {
44519+ uint64_t arg = heap.data[0].elem0;
44520+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44521+ }
44522+ {
44523+ uint64_t arg = 0;
44524+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44525+ }
44526+ // ACCUMULATE ARGUMENTS - BEGIN
4448644527 {
44487- uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU);
44528+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
44529+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44530+ }
44531+ {
44532+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 8LLU, 1LLU);
4448844533 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4448944534 }
4449044535 // ACCUMULATE ARGUMENTS - END
44491- uint64_t return_to = 18446744073709549653LLU;
44536+ uint64_t return_to = 18446744073709549649LLU;
4449244537 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4449344538 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4449444539 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44497,18 +44542,21 @@
4449744542 state.addr = 367395560426147840LLU; // TYPECOPY__
4449844543 break;
4449944544 }
44500- case 18446744073709549653LLU: // 99999999fU'''''''''''''''
44545+ case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
4450144546 {
4450244547 {
44503- uint64_t arg = 0;
44504- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44548+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
44549+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
44550+
44551+ {
44552+ uint64_t arg = exchange;
44553+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44554+ }
4450544555 }
44506- *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
4450744556 {
44508- uint64_t arg = 0;
44557+ uint64_t arg = heap.data[0].elem0;
4450944558 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4451044559 }
44511- *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
4451244560 {
4451344561 uint64_t arg = 0;
4451444562 LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
@@ -44519,19 +44567,70 @@
4451944567 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4452044568 }
4452144569 {
44522- uint64_t arg = /*TYPE______*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
44570+ uint64_t arg = /*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 2LLU));
4452344571 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4452444572 }
44573+ // ACCUMULATE ARGUMENTS - END
44574+ uint64_t return_to = 18446744073709549648LLU;
44575+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
44576+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44577+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44578+ heap.data[0].elem1 = heap.data[0].elem0;
44579+ heap.data[0].elem0 = restore;
44580+ state.addr = 552446646280519680LLU; // copyu64___
44581+ break;
44582+ }
44583+ case 18446744073709549648LLU: // 99999999fP'''''''''''''''
44584+ {
44585+ {
44586+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
44587+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
44588+
4452544589 {
44526- uint64_t arg = /*idx_______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
44590+ uint64_t arg = exchange;
4452744591 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4452844592 }
44593+ }
44594+ {
44595+ uint64_t arg = heap.data[0].elem0;
44596+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44597+ }
44598+ {
44599+ uint64_t arg = 0;
44600+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44601+ }
44602+ // ACCUMULATE ARGUMENTS - BEGIN
4452944603 {
44530- uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 8LLU, 6LLU);
44604+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
44605+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44606+ }
44607+ {
44608+ uint64_t arg = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU));
44609+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44610+ }
44611+ // ACCUMULATE ARGUMENTS - END
44612+ uint64_t return_to = 18446744073709549647LLU;
44613+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
44614+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44615+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44616+ heap.data[0].elem1 = heap.data[0].elem0;
44617+ heap.data[0].elem0 = restore;
44618+ state.addr = 552446646280519680LLU; // copyu64___
44619+ break;
44620+ }
44621+ case 18446744073709549647LLU: // 99999999fO'''''''''''''''
44622+ {
44623+ {
44624+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
44625+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
44626+
44627+ {
44628+ uint64_t arg = exchange;
4453144629 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4453244630 }
44631+ }
4453344632 // ACCUMULATE ARGUMENTS - END
44534- uint64_t return_to = 18446744073709549649LLU;
44633+ uint64_t return_to = 18446744073709549650LLU;
4453544634 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4453644635 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4453744636 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44540,12 +44639,12 @@
4454044639 state.addr = 819859607768530944LLU; // resdest___
4454144640 break;
4454244641 }
44543- case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
44642+ case 18446744073709549650LLU: // 99999999fR'''''''''''''''
4454444643 {
44545- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)), 8) ? 18446744073709549652LLU : 18446744073709549651LLU;
44644+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 8) ? 18446744073709549653LLU : 18446744073709549652LLU;
4454644645 break;
4454744646 }
44548- case 18446744073709549652LLU: // 99999999fT'''''''''''''''
44647+ case 18446744073709549653LLU: // 99999999fU'''''''''''''''
4454944648 {
4455044649 {
4455144650 fprintf(stderr, "%s\n", "INTERNAL ERROR - out of dynamic heap in oneresult - recompile compiler with more dynamic heap");
@@ -44554,11 +44653,11 @@
4455444653 // emitted destructur for type resdest___
4455544654 // ACCUMULATE ARGUMENTS - BEGIN
4455644655 {
44557- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
44656+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
4455844657 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4455944658 }
4456044659 // ACCUMULATE ARGUMENTS - END
44561- uint64_t return_to = 18446744073709549648LLU;
44660+ uint64_t return_to = 18446744073709549646LLU;
4456244661 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4456344662 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4456444663 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44567,29 +44666,24 @@
4456744666 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4456844667 break;
4456944668 }
44570- case 18446744073709549648LLU: // 99999999fP'''''''''''''''
44669+ case 18446744073709549646LLU: // 99999999fN'''''''''''''''
4457144670 {
4457244671 // parameter resdest___ tmp_______ goes out of scope
44573- state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
44672+ state.addr = 18446744073709549651LLU; // 99999999fS'''''''''''''''
4457444673 break;
4457544674 }
44576- case 18446744073709549651LLU: // 99999999fS'''''''''''''''
44675+ case 18446744073709549652LLU: // 99999999fT'''''''''''''''
4457744676 {
44578- state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
44677+ state.addr = 18446744073709549651LLU; // 99999999fS'''''''''''''''
4457944678 break;
4458044679 }
44581- case 18446744073709549650LLU: // 99999999fR'''''''''''''''
44680+ case 18446744073709549651LLU: // 99999999fS'''''''''''''''
4458244681 {
44583- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
44584- // variable u64 reference_ goes out of scope
44682+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
44683+ swap(&*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
44684+ // variable list<resdest___> results___ goes out of scope
4458544685 // (uninitialized -> no destructor-call)
44586- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 7
44587- // variable u64 idx_______ goes out of scope
44588- // (uninitialized -> no destructor-call)
44589- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 6
44590- // variable type______ TYPE______ goes out of scope
44591- // (uninitialized -> no destructor-call)
44592- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPE______ at 5
44686+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 5
4459344687 // parameter-reference u64 reference_ goes out of scope
4459444688 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 4
4459544689 // parameter-reference u64 idx_______ goes out of scope
@@ -44596,8 +44690,7 @@
4459644690 (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 3
4459744691 // parameter-reference type______ type______ goes out of scope
4459844692 (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 2
44599- // parameter-reference list<resdest___> results___ goes out of scope
44600- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 1
44693+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4460144694 {
4460244695 uint64_t baseinfo = heap.data[0].elem1;
4460344696 struct pair pair = unpair(&heap, &baseinfo);
@@ -44619,11 +44712,11 @@
4461944712 LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4462044713 }
4462144714 *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*sz________*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
44622- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549647LLU : 18446744073709549646LLU;
44715+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549645LLU : 18446744073709549644LLU;
4462344716 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4462444717 break;
4462544718 }
44626- case 18446744073709549647LLU: // 99999999fO'''''''''''''''
44719+ case 18446744073709549645LLU: // 99999999fM'''''''''''''''
4462744720 {
4462844721 ++/*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
4462944722 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44632,7 +44725,7 @@
4463244725 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4463344726 }
4463444727 // ACCUMULATE ARGUMENTS - END
44635- uint64_t return_to = 18446744073709549645LLU;
44728+ uint64_t return_to = 18446744073709549643LLU;
4463644729 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4463744730 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4463844731 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44641,7 +44734,7 @@
4464144734 state.addr = 819847183515949359LLU; // reportinit
4464244735 break;
4464344736 }
44644- case 18446744073709549645LLU: // 99999999fM'''''''''''''''
44737+ case 18446744073709549643LLU: // 99999999fK'''''''''''''''
4464544738 {
4464644739 fprintf(stderr, "%s", "built-in function returns (u64) but caller expects ");
4464744740 fprintf(stderr, "%llu", (unsigned long long)/*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));
@@ -44650,10 +44743,10 @@
4465044743 fprintf(stderr, "%s\n", "");
4465144744 exit(-1);
4465244745 }
44653- state.addr = 18446744073709549646LLU; // 99999999fN'''''''''''''''
44746+ state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
4465444747 break;
4465544748 }
44656- case 18446744073709549646LLU: // 99999999fN'''''''''''''''
44749+ case 18446744073709549644LLU: // 99999999fL'''''''''''''''
4465744750 {
4465844751 {
4465944752 uint64_t arg = /*res_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
@@ -44663,10 +44756,10 @@
4466344756 uint64_t arg = 0;
4466444757 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4466544758 }
44666- state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
44759+ state.addr = 18446744073709549642LLU; // 99999999fJ'''''''''''''''
4466744760 break;
4466844761 }
44669- case 18446744073709549644LLU: // 99999999fL'''''''''''''''
44762+ case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
4467044763 {
4467144764 if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
4467244765 {
@@ -44673,7 +44766,7 @@
4467344766 (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
4467444767 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4467544768 {
44676- state.addr = 18446744073709549643LLU; // 99999999fK'''''''''''''''
44769+ state.addr = 18446744073709549641LLU; // 99999999fI'''''''''''''''
4467744770 break;
4467844771 }
4467944772 }
@@ -44687,7 +44780,7 @@
4468744780 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4468844781 }
4468944782 // ACCUMULATE ARGUMENTS - END
44690- uint64_t return_to = 18446744073709549642LLU;
44783+ uint64_t return_to = 18446744073709549640LLU;
4469144784 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4469244785 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4469344786 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44696,7 +44789,7 @@
4469644789 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4469744790 break;
4469844791 }
44699- case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
44792+ case 18446744073709549640LLU: // 99999999fH'''''''''''''''
4470044793 {
4470144794 // ACCUMULATE ARGUMENTS - BEGIN
4470244795 {
@@ -44708,7 +44801,7 @@
4470844801 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4470944802 }
4471044803 // ACCUMULATE ARGUMENTS - END
44711- uint64_t return_to = 18446744073709549641LLU;
44804+ uint64_t return_to = 18446744073709549639LLU;
4471244805 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4471344806 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4471444807 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44717,14 +44810,14 @@
4471744810 state.addr = 325750391286068249LLU; // RESDEFCOPY
4471844811 break;
4471944812 }
44720- case 18446744073709549641LLU: // 99999999fI'''''''''''''''
44813+ case 18446744073709549639LLU: // 99999999fG'''''''''''''''
4472144814 {
4472244815 // parameter-reference resdest___ tmp_______ goes out of scope
4472344816 // parameter-reference list<resdest___> res_______ goes out of scope
44724- state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
44817+ state.addr = 18446744073709549642LLU; // 99999999fJ'''''''''''''''
4472544818 break;
4472644819 }
44727- case 18446744073709549643LLU: // 99999999fK'''''''''''''''
44820+ case 18446744073709549641LLU: // 99999999fI'''''''''''''''
4472844821 {
4472944822 // variable u64 sz________ goes out of scope
4473044823 // emitted destructur for type u64
@@ -44758,11 +44851,11 @@
4475844851 LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4475944852 }
4476044853 *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
44761- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549640LLU : 18446744073709549639LLU;
44854+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549638LLU : 18446744073709549637LLU;
4476244855 (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
4476344856 break;
4476444857 }
44765- case 18446744073709549640LLU: // 99999999fH'''''''''''''''
44858+ case 18446744073709549638LLU: // 99999999fF'''''''''''''''
4476644859 {
4476744860 ++/*sz________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
4476844861 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44771,7 +44864,7 @@
4477144864 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4477244865 }
4477344866 // ACCUMULATE ARGUMENTS - END
44774- uint64_t return_to = 18446744073709549638LLU;
44867+ uint64_t return_to = 18446744073709549636LLU;
4477544868 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4477644869 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4477744870 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44780,7 +44873,7 @@
4478044873 state.addr = 819847183515949359LLU; // reportinit
4478144874 break;
4478244875 }
44783- case 18446744073709549638LLU: // 99999999fF'''''''''''''''
44876+ case 18446744073709549636LLU: // 99999999fD'''''''''''''''
4478444877 {
4478544878 fprintf(stderr, "%s", "found ");
4478644879 fprintf(stderr, "%llu", (unsigned long long)/*sz________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
@@ -44789,10 +44882,10 @@
4478944882 fprintf(stderr, "%s\n", "");
4479044883 exit(-1);
4479144884 }
44792- state.addr = 18446744073709549639LLU; // 99999999fG'''''''''''''''
44885+ state.addr = 18446744073709549637LLU; // 99999999fE'''''''''''''''
4479344886 break;
4479444887 }
44795- case 18446744073709549639LLU: // 99999999fG'''''''''''''''
44888+ case 18446744073709549637LLU: // 99999999fE'''''''''''''''
4479644889 {
4479744890 {
4479844891 uint64_t arg = 0;
@@ -44817,7 +44910,7 @@
4481744910 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4481844911 }
4481944912 // ACCUMULATE ARGUMENTS - END
44820- uint64_t return_to = 18446744073709549636LLU;
44913+ uint64_t return_to = 18446744073709549634LLU;
4482144914 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4482244915 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4482344916 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44826,7 +44919,7 @@
4482644919 state.addr = 861504796319285248LLU; // typeu64___
4482744920 break;
4482844921 }
44829- case 18446744073709549636LLU: // 99999999fD'''''''''''''''
44922+ case 18446744073709549634LLU: // 99999999fB'''''''''''''''
4483044923 {
4483144924 {
4483244925 uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
@@ -44846,7 +44939,7 @@
4484644939 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4484744940 }
4484844941 // ACCUMULATE ARGUMENTS - END
44849- uint64_t return_to = 18446744073709549637LLU;
44942+ uint64_t return_to = 18446744073709549635LLU;
4485044943 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4485144944 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4485244945 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44855,7 +44948,7 @@
4485544948 state.addr = 819859607768530944LLU; // resdest___
4485644949 break;
4485744950 }
44858- case 18446744073709549637LLU: // 99999999fE'''''''''''''''
44951+ case 18446744073709549635LLU: // 99999999fC'''''''''''''''
4485944952 {
4486044953 {
4486144954 uint64_t arg = /*res_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU));
@@ -44865,10 +44958,10 @@
4486544958 uint64_t arg = 0;
4486644959 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4486744960 }
44868- state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
44961+ state.addr = 18446744073709549633LLU; // 99999999fA'''''''''''''''
4486944962 break;
4487044963 }
44871- case 18446744073709549635LLU: // 99999999fC'''''''''''''''
44964+ case 18446744073709549633LLU: // 99999999fA'''''''''''''''
4487244965 {
4487344966 if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
4487444967 {
@@ -44875,7 +44968,7 @@
4487544968 (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
4487644969 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4487744970 {
44878- state.addr = 18446744073709549634LLU; // 99999999fB'''''''''''''''
44971+ state.addr = 18446744073709549632LLU; // 99999999f_'''''''''''''''
4487944972 break;
4488044973 }
4488144974 }
@@ -44889,7 +44982,7 @@
4488944982 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4489044983 }
4489144984 // ACCUMULATE ARGUMENTS - END
44892- uint64_t return_to = 18446744073709549633LLU;
44985+ uint64_t return_to = 18446744073709549631LLU;
4489344986 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4489444987 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4489544988 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44898,7 +44991,7 @@
4489844991 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4489944992 break;
4490044993 }
44901- case 18446744073709549633LLU: // 99999999fA'''''''''''''''
44994+ case 18446744073709549631LLU: // 99999999e9'''''''''''''''
4490244995 {
4490344996 // ACCUMULATE ARGUMENTS - BEGIN
4490444997 {
@@ -44910,7 +45003,7 @@
4491045003 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4491145004 }
4491245005 // ACCUMULATE ARGUMENTS - END
44913- uint64_t return_to = 18446744073709549632LLU;
45006+ uint64_t return_to = 18446744073709549630LLU;
4491445007 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4491545008 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4491645009 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44919,14 +45012,14 @@
4491945012 state.addr = 325750391286068249LLU; // RESDEFCOPY
4492045013 break;
4492145014 }
44922- case 18446744073709549632LLU: // 99999999f_'''''''''''''''
45015+ case 18446744073709549630LLU: // 99999999e8'''''''''''''''
4492345016 {
4492445017 // parameter-reference resdest___ tmp_______ goes out of scope
4492545018 // parameter-reference list<resdest___> res_______ goes out of scope
44926- state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
45019+ state.addr = 18446744073709549633LLU; // 99999999fA'''''''''''''''
4492745020 break;
4492845021 }
44929- case 18446744073709549634LLU: // 99999999fB'''''''''''''''
45022+ case 18446744073709549632LLU: // 99999999f_'''''''''''''''
4493045023 {
4493145024 swap(&*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
4493245025 // variable resdest___ single____ goes out of scope
@@ -44968,7 +45061,7 @@
4496845061 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4496945062 }
4497045063 // ACCUMULATE ARGUMENTS - END
44971- uint64_t return_to = 18446744073709549631LLU;
45064+ uint64_t return_to = 18446744073709549629LLU;
4497245065 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4497345066 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4497445067 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44977,7 +45070,7 @@
4497745070 state.addr = 819857492327934432LLU; // res_single
4497845071 break;
4497945072 }
44980- case 18446744073709549631LLU: // 99999999e9'''''''''''''''
45073+ case 18446744073709549629LLU: // 99999999e7'''''''''''''''
4498145074 {
4498245075 // ACCUMULATE ARGUMENTS - BEGIN
4498345076 {
@@ -44989,7 +45082,7 @@
4498945082 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4499045083 }
4499145084 // ACCUMULATE ARGUMENTS - END
44992- uint64_t return_to = 18446744073709549630LLU;
45085+ uint64_t return_to = 18446744073709549628LLU;
4499345086 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4499445087 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4499545088 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44998,7 +45091,7 @@
4499845091 state.addr = 517555565476695680LLU; // assertu64_
4499945092 break;
4500045093 }
45001- case 18446744073709549630LLU: // 99999999e8'''''''''''''''
45094+ case 18446744073709549628LLU: // 99999999e6'''''''''''''''
4500245095 {
4500345096 // parameter-reference list<resdest___> res_______ goes out of scope
4500445097 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res_______ at 4
@@ -45032,11 +45125,11 @@
4503245125 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4503345126 }
4503445127 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45035- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549629LLU : 18446744073709549628LLU;
45128+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549627LLU : 18446744073709549626LLU;
4503645129 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4503745130 break;
4503845131 }
45039- case 18446744073709549629LLU: // 99999999e7'''''''''''''''
45132+ case 18446744073709549627LLU: // 99999999e5'''''''''''''''
4504045133 {
4504145134 {
4504245135 uint64_t arg = 0;
@@ -45061,7 +45154,7 @@
4506145154 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4506245155 }
4506345156 // ACCUMULATE ARGUMENTS - END
45064- uint64_t return_to = 18446744073709549625LLU;
45157+ uint64_t return_to = 18446744073709549623LLU;
4506545158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4506645159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4506745160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45070,7 +45163,7 @@
4507045163 state.addr = 861504796319285248LLU; // typeu64___
4507145164 break;
4507245165 }
45073- case 18446744073709549625LLU: // 99999999e3'''''''''''''''
45166+ case 18446744073709549623LLU: // 99999999e1'''''''''''''''
4507445167 {
4507545168 {
4507645169 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -45090,7 +45183,7 @@
4509045183 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4509145184 }
4509245185 // ACCUMULATE ARGUMENTS - END
45093- uint64_t return_to = 18446744073709549626LLU;
45186+ uint64_t return_to = 18446744073709549624LLU;
4509445187 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4509545188 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4509645189 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45099,7 +45192,7 @@
4509945192 state.addr = 819859607768530944LLU; // resdest___
4510045193 break;
4510145194 }
45102- case 18446744073709549626LLU: // 99999999e4'''''''''''''''
45195+ case 18446744073709549624LLU: // 99999999e2'''''''''''''''
4510345196 {
4510445197 // ACCUMULATE ARGUMENTS - BEGIN
4510545198 {
@@ -45119,7 +45212,7 @@
4511945212 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4512045213 }
4512145214 // ACCUMULATE ARGUMENTS - END
45122- uint64_t return_to = 18446744073709549624LLU;
45215+ uint64_t return_to = 18446744073709549622LLU;
4512345216 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4512445217 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4512545218 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45128,7 +45221,7 @@
4512845221 state.addr = 819857494882385920LLU; // res_u64___
4512945222 break;
4513045223 }
45131- case 18446744073709549624LLU: // 99999999e2'''''''''''''''
45224+ case 18446744073709549622LLU: // 99999999e0'''''''''''''''
4513245225 {
4513345226 // ACCUMULATE ARGUMENTS - BEGIN
4513445227 {
@@ -45136,7 +45229,7 @@
4513645229 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4513745230 }
4513845231 // ACCUMULATE ARGUMENTS - END
45139- uint64_t return_to = 18446744073709549623LLU;
45232+ uint64_t return_to = 18446744073709549621LLU;
4514045233 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4514145234 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4514245235 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45145,7 +45238,7 @@
4514545238 state.addr = 839519665163075584LLU; // skip______
4514645239 break;
4514745240 }
45148- case 18446744073709549623LLU: // 99999999e1'''''''''''''''
45241+ case 18446744073709549621LLU: // 99999999ez'''''''''''''''
4514945242 {
4515045243 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4515145244 fprintf(stdout, "%s", "\n ");
@@ -45171,7 +45264,7 @@
4517145264 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4517245265 }
4517345266 // ACCUMULATE ARGUMENTS - END
45174- uint64_t return_to = 18446744073709549622LLU;
45267+ uint64_t return_to = 18446744073709549620LLU;
4517545268 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4517645269 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4517745270 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45180,7 +45273,7 @@
4518045273 state.addr = 587881357514113024LLU; // emitpar___
4518145274 break;
4518245275 }
45183- case 18446744073709549622LLU: // 99999999e0'''''''''''''''
45276+ case 18446744073709549620LLU: // 99999999ey'''''''''''''''
4518445277 {
4518545278 fprintf(stdout, "%s", " = (uint64_t)getchar();");
4518645279 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45189,7 +45282,7 @@
4518945282 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4519045283 }
4519145284 // ACCUMULATE ARGUMENTS - END
45192- uint64_t return_to = 18446744073709549621LLU;
45285+ uint64_t return_to = 18446744073709549619LLU;
4519345286 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4519445287 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4519545288 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45198,7 +45291,7 @@
4519845291 state.addr = 839519665163075584LLU; // skip______
4519945292 break;
4520045293 }
45201- case 18446744073709549621LLU: // 99999999ez'''''''''''''''
45294+ case 18446744073709549619LLU: // 99999999ex'''''''''''''''
4520245295 {
4520345296 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4520445297 // variable resdest___ single____ goes out of scope
@@ -45209,7 +45302,7 @@
4520945302 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4521045303 }
4521145304 // ACCUMULATE ARGUMENTS - END
45212- uint64_t return_to = 18446744073709549620LLU;
45305+ uint64_t return_to = 18446744073709549618LLU;
4521345306 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4521445307 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4521545308 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45218,13 +45311,13 @@
4521845311 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4521945312 break;
4522045313 }
45221- case 18446744073709549620LLU: // 99999999ey'''''''''''''''
45314+ case 18446744073709549618LLU: // 99999999ew'''''''''''''''
4522245315 {
4522345316 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
45224- state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
45317+ state.addr = 18446744073709549625LLU; // 99999999e3'''''''''''''''
4522545318 break;
4522645319 }
45227- case 18446744073709549628LLU: // 99999999e6'''''''''''''''
45320+ case 18446744073709549626LLU: // 99999999e4'''''''''''''''
4522845321 {
4522945322
4523045323 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 783769716797919232;
@@ -45235,11 +45328,11 @@
4523545328 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4523645329 }
4523745330 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45238- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549619LLU : 18446744073709549618LLU;
45331+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549617LLU : 18446744073709549616LLU;
4523945332 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4524045333 break;
4524145334 }
45242- case 18446744073709549619LLU: // 99999999ex'''''''''''''''
45335+ case 18446744073709549617LLU: // 99999999ev'''''''''''''''
4524345336 {
4524445337 {
4524545338 uint64_t arg = 0;
@@ -45264,7 +45357,7 @@
4526445357 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4526545358 }
4526645359 // ACCUMULATE ARGUMENTS - END
45267- uint64_t return_to = 18446744073709549615LLU;
45360+ uint64_t return_to = 18446744073709549613LLU;
4526845361 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4526945362 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4527045363 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45273,7 +45366,7 @@
4527345366 state.addr = 861504796319285248LLU; // typeu64___
4527445367 break;
4527545368 }
45276- case 18446744073709549615LLU: // 99999999et'''''''''''''''
45369+ case 18446744073709549613LLU: // 99999999er'''''''''''''''
4527745370 {
4527845371 {
4527945372 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -45293,7 +45386,7 @@
4529345386 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4529445387 }
4529545388 // ACCUMULATE ARGUMENTS - END
45296- uint64_t return_to = 18446744073709549616LLU;
45389+ uint64_t return_to = 18446744073709549614LLU;
4529745390 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4529845391 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4529945392 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45302,7 +45395,7 @@
4530245395 state.addr = 819859607768530944LLU; // resdest___
4530345396 break;
4530445397 }
45305- case 18446744073709549616LLU: // 99999999eu'''''''''''''''
45398+ case 18446744073709549614LLU: // 99999999es'''''''''''''''
4530645399 {
4530745400 // ACCUMULATE ARGUMENTS - BEGIN
4530845401 {
@@ -45322,7 +45415,7 @@
4532245415 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4532345416 }
4532445417 // ACCUMULATE ARGUMENTS - END
45325- uint64_t return_to = 18446744073709549614LLU;
45418+ uint64_t return_to = 18446744073709549612LLU;
4532645419 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4532745420 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4532845421 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45331,7 +45424,7 @@
4533145424 state.addr = 819857494882385920LLU; // res_u64___
4533245425 break;
4533345426 }
45334- case 18446744073709549614LLU: // 99999999es'''''''''''''''
45427+ case 18446744073709549612LLU: // 99999999eq'''''''''''''''
4533545428 {
4533645429 // ACCUMULATE ARGUMENTS - BEGIN
4533745430 {
@@ -45339,7 +45432,7 @@
4533945432 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4534045433 }
4534145434 // ACCUMULATE ARGUMENTS - END
45342- uint64_t return_to = 18446744073709549613LLU;
45435+ uint64_t return_to = 18446744073709549611LLU;
4534345436 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4534445437 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4534545438 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45348,7 +45441,7 @@
4534845441 state.addr = 839519665163075584LLU; // skip______
4534945442 break;
4535045443 }
45351- case 18446744073709549613LLU: // 99999999er'''''''''''''''
45444+ case 18446744073709549611LLU: // 99999999ep'''''''''''''''
4535245445 {
4535345446 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4535445447 fprintf(stdout, "%s", "\n ");
@@ -45374,7 +45467,7 @@
4537445467 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4537545468 }
4537645469 // ACCUMULATE ARGUMENTS - END
45377- uint64_t return_to = 18446744073709549612LLU;
45470+ uint64_t return_to = 18446744073709549610LLU;
4537845471 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4537945472 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4538045473 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45383,7 +45476,7 @@
4538345476 state.addr = 587881357514113024LLU; // emitpar___
4538445477 break;
4538545478 }
45386- case 18446744073709549612LLU: // 99999999eq'''''''''''''''
45479+ case 18446744073709549610LLU: // 99999999eo'''''''''''''''
4538745480 {
4538845481 fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
4538945482 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45392,7 +45485,7 @@
4539245485 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4539345486 }
4539445487 // ACCUMULATE ARGUMENTS - END
45395- uint64_t return_to = 18446744073709549611LLU;
45488+ uint64_t return_to = 18446744073709549609LLU;
4539645489 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4539745490 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4539845491 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45401,7 +45494,7 @@
4540145494 state.addr = 839519665163075584LLU; // skip______
4540245495 break;
4540345496 }
45404- case 18446744073709549611LLU: // 99999999ep'''''''''''''''
45497+ case 18446744073709549609LLU: // 99999999en'''''''''''''''
4540545498 {
4540645499 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4540745500 // variable resdest___ single____ goes out of scope
@@ -45412,7 +45505,7 @@
4541245505 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4541345506 }
4541445507 // ACCUMULATE ARGUMENTS - END
45415- uint64_t return_to = 18446744073709549610LLU;
45508+ uint64_t return_to = 18446744073709549608LLU;
4541645509 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4541745510 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4541845511 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45421,23 +45514,23 @@
4542145514 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4542245515 break;
4542345516 }
45424- case 18446744073709549610LLU: // 99999999eo'''''''''''''''
45517+ case 18446744073709549608LLU: // 99999999em'''''''''''''''
4542545518 {
4542645519 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
45427- state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
45520+ state.addr = 18446744073709549615LLU; // 99999999et'''''''''''''''
4542845521 break;
4542945522 }
45430- case 18446744073709549618LLU: // 99999999ew'''''''''''''''
45523+ case 18446744073709549616LLU: // 99999999eu'''''''''''''''
4543145524 {
45432- state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
45525+ state.addr = 18446744073709549615LLU; // 99999999et'''''''''''''''
4543345526 break;
4543445527 }
45435- case 18446744073709549617LLU: // 99999999ev'''''''''''''''
45528+ case 18446744073709549615LLU: // 99999999et'''''''''''''''
4543645529 {
45437- state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
45530+ state.addr = 18446744073709549625LLU; // 99999999e3'''''''''''''''
4543845531 break;
4543945532 }
45440- case 18446744073709549627LLU: // 99999999e5'''''''''''''''
45533+ case 18446744073709549625LLU: // 99999999e3'''''''''''''''
4544145534 {
4544245535 // variable u64 sym_______ goes out of scope
4544345536 // emitted destructur for type u64
@@ -45496,11 +45589,11 @@
4549645589 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4549745590 }
4549845591 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45499- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549609LLU : 18446744073709549608LLU;
45592+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549607LLU : 18446744073709549606LLU;
4550045593 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4550145594 break;
4550245595 }
45503- case 18446744073709549609LLU: // 99999999en'''''''''''''''
45596+ case 18446744073709549607LLU: // 99999999el'''''''''''''''
4550445597 {
4550545598 {
4550645599 uint64_t arg = 0;
@@ -45527,7 +45620,7 @@
4552745620 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4552845621 }
4552945622 // ACCUMULATE ARGUMENTS - END
45530- uint64_t return_to = 18446744073709549606LLU;
45623+ uint64_t return_to = 18446744073709549604LLU;
4553145624 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4553245625 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4553345626 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45536,7 +45629,7 @@
4553645629 state.addr = 861504796319285248LLU; // typeu64___
4553745630 break;
4553845631 }
45539- case 18446744073709549606LLU: // 99999999ek'''''''''''''''
45632+ case 18446744073709549604LLU: // 99999999ei'''''''''''''''
4554045633 {
4554145634 {
4554245635 uint64_t arg = 0;
@@ -45561,7 +45654,7 @@
4556145654 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4556245655 }
4556345656 // ACCUMULATE ARGUMENTS - END
45564- uint64_t return_to = 18446744073709549604LLU;
45657+ uint64_t return_to = 18446744073709549602LLU;
4556545658 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4556645659 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4556745660 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45570,7 +45663,7 @@
4557045663 state.addr = 861504796319285248LLU; // typeu64___
4557145664 break;
4557245665 }
45573- case 18446744073709549604LLU: // 99999999ei'''''''''''''''
45666+ case 18446744073709549602LLU: // 99999999eg'''''''''''''''
4557445667 {
4557545668 {
4557645669 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -45590,7 +45683,7 @@
4559045683 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4559145684 }
4559245685 // ACCUMULATE ARGUMENTS - END
45593- uint64_t return_to = 18446744073709549605LLU;
45686+ uint64_t return_to = 18446744073709549603LLU;
4559445687 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4559545688 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4559645689 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45599,7 +45692,7 @@
4559945692 state.addr = 819859607768530944LLU; // resdest___
4560045693 break;
4560145694 }
45602- case 18446744073709549605LLU: // 99999999ej'''''''''''''''
45695+ case 18446744073709549603LLU: // 99999999eh'''''''''''''''
4560345696 {
4560445697 // ACCUMULATE ARGUMENTS - BEGIN
4560545698 {
@@ -45619,7 +45712,7 @@
4561945712 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4562045713 }
4562145714 // ACCUMULATE ARGUMENTS - END
45622- uint64_t return_to = 18446744073709549603LLU;
45715+ uint64_t return_to = 18446744073709549601LLU;
4562345716 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4562445717 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4562545718 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45628,7 +45721,7 @@
4562845721 state.addr = 819857494882385920LLU; // res_u64___
4562945722 break;
4563045723 }
45631- case 18446744073709549603LLU: // 99999999eh'''''''''''''''
45724+ case 18446744073709549601LLU: // 99999999ef'''''''''''''''
4563245725 {
4563345726 // ACCUMULATE ARGUMENTS - BEGIN
4563445727 {
@@ -45636,7 +45729,7 @@
4563645729 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4563745730 }
4563845731 // ACCUMULATE ARGUMENTS - END
45639- uint64_t return_to = 18446744073709549602LLU;
45732+ uint64_t return_to = 18446744073709549600LLU;
4564045733 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4564145734 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4564245735 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45645,7 +45738,7 @@
4564545738 state.addr = 839519665163075584LLU; // skip______
4564645739 break;
4564745740 }
45648- case 18446744073709549602LLU: // 99999999eg'''''''''''''''
45741+ case 18446744073709549600LLU: // 99999999ee'''''''''''''''
4564945742 {
4565045743 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4565145744 fprintf(stdout, "%s", "\n ");
@@ -45671,7 +45764,7 @@
4567145764 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4567245765 }
4567345766 // ACCUMULATE ARGUMENTS - END
45674- uint64_t return_to = 18446744073709549601LLU;
45767+ uint64_t return_to = 18446744073709549599LLU;
4567545768 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4567645769 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4567745770 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45680,7 +45773,7 @@
4568045773 state.addr = 587881357514113024LLU; // emitpar___
4568145774 break;
4568245775 }
45683- case 18446744073709549601LLU: // 99999999ef'''''''''''''''
45776+ case 18446744073709549599LLU: // 99999999ed'''''''''''''''
4568445777 {
4568545778 fprintf(stdout, "%s", " = ~");
4568645779 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45689,7 +45782,7 @@
4568945782 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4569045783 }
4569145784 // ACCUMULATE ARGUMENTS - END
45692- uint64_t return_to = 18446744073709549600LLU;
45785+ uint64_t return_to = 18446744073709549598LLU;
4569345786 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4569445787 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4569545788 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45698,7 +45791,7 @@
4569845791 state.addr = 839519665163075584LLU; // skip______
4569945792 break;
4570045793 }
45701- case 18446744073709549600LLU: // 99999999ee'''''''''''''''
45794+ case 18446744073709549598LLU: // 99999999ec'''''''''''''''
4570245795 {
4570345796
4570445797 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -45720,7 +45813,7 @@
4572045813 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4572145814 }
4572245815 // ACCUMULATE ARGUMENTS - END
45723- uint64_t return_to = 18446744073709549599LLU;
45816+ uint64_t return_to = 18446744073709549597LLU;
4572445817 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4572545818 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4572645819 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45729,7 +45822,7 @@
4572945822 state.addr = 23446349213393492LLU; // ASSERTINIT
4573045823 break;
4573145824 }
45732- case 18446744073709549599LLU: // 99999999ed'''''''''''''''
45825+ case 18446744073709549597LLU: // 99999999eb'''''''''''''''
4573345826 {
4573445827 {
4573545828 uint64_t arg = 0;
@@ -45808,7 +45901,7 @@
4580845901 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4580945902 }
4581045903 // ACCUMULATE ARGUMENTS - END
45811- uint64_t return_to = 18446744073709549598LLU;
45904+ uint64_t return_to = 18446744073709549596LLU;
4581245905 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4581345906 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4581445907 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45817,7 +45910,7 @@
4581745910 state.addr = 293363126232490310LLU; // PROCVARREF
4581845911 break;
4581945912 }
45820- case 18446744073709549598LLU: // 99999999ec'''''''''''''''
45913+ case 18446744073709549596LLU: // 99999999ea'''''''''''''''
4582145914 {
4582245915 // variable u64 initialize goes out of scope
4582345916 // emitted destructur for type u64
@@ -45838,7 +45931,7 @@
4583845931 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4583945932 }
4584045933 // ACCUMULATE ARGUMENTS - END
45841- uint64_t return_to = 18446744073709549597LLU;
45934+ uint64_t return_to = 18446744073709549595LLU;
4584245935 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4584345936 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4584445937 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45847,7 +45940,7 @@
4584745940 state.addr = 517555565476695680LLU; // assertu64_
4584845941 break;
4584945942 }
45850- case 18446744073709549597LLU: // 99999999eb'''''''''''''''
45943+ case 18446744073709549595LLU: // 99999999e$'''''''''''''''
4585145944 {
4585245945 // ACCUMULATE ARGUMENTS - BEGIN
4585345946 {
@@ -45855,7 +45948,7 @@
4585545948 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4585645949 }
4585745950 // ACCUMULATE ARGUMENTS - END
45858- uint64_t return_to = 18446744073709549596LLU;
45951+ uint64_t return_to = 18446744073709549594LLU;
4585945952 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4586045953 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4586145954 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45864,7 +45957,7 @@
4586445957 state.addr = 839519665163075584LLU; // skip______
4586545958 break;
4586645959 }
45867- case 18446744073709549596LLU: // 99999999ea'''''''''''''''
45960+ case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
4586845961 {
4586945962 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4587045963 fprintf(stdout, "%s", ";");
@@ -45876,7 +45969,7 @@
4587645969 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4587745970 }
4587845971 // ACCUMULATE ARGUMENTS - END
45879- uint64_t return_to = 18446744073709549595LLU;
45972+ uint64_t return_to = 18446744073709549593LLU;
4588045973 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4588145974 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4588245975 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45885,7 +45978,7 @@
4588545978 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4588645979 break;
4588745980 }
45888- case 18446744073709549595LLU: // 99999999e$'''''''''''''''
45981+ case 18446744073709549593LLU: // 99999999eY'''''''''''''''
4588945982 {
4589045983 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4589145984 // variable type______ type______ goes out of scope
@@ -45896,7 +45989,7 @@
4589645989 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4589745990 }
4589845991 // ACCUMULATE ARGUMENTS - END
45899- uint64_t return_to = 18446744073709549594LLU;
45992+ uint64_t return_to = 18446744073709549592LLU;
4590045993 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4590145994 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4590245995 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45905,7 +45998,7 @@
4590545998 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4590645999 break;
4590746000 }
45908- case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
46001+ case 18446744073709549592LLU: // 99999999eX'''''''''''''''
4590946002 {
4591046003 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4591146004 // variable u64 mutable___ goes out of scope
@@ -45917,10 +46010,10 @@
4591746010 // variable u64 id________ goes out of scope
4591846011 // emitted destructur for type u64
4591946012 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
45920- state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
46013+ state.addr = 18446744073709549605LLU; // 99999999ej'''''''''''''''
4592146014 break;
4592246015 }
45923- case 18446744073709549608LLU: // 99999999em'''''''''''''''
46016+ case 18446744073709549606LLU: // 99999999ek'''''''''''''''
4592446017 {
4592546018
4592646019 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750618996096630784;
@@ -45931,11 +46024,11 @@
4593146024 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4593246025 }
4593346026 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45934- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549593LLU : 18446744073709549592LLU;
46027+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549591LLU : 18446744073709549590LLU;
4593546028 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4593646029 break;
4593746030 }
45938- case 18446744073709549593LLU: // 99999999eY'''''''''''''''
46031+ case 18446744073709549591LLU: // 99999999eW'''''''''''''''
4593946032 {
4594046033 {
4594146034 uint64_t arg = 0;
@@ -45962,7 +46055,7 @@
4596246055 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4596346056 }
4596446057 // ACCUMULATE ARGUMENTS - END
45965- uint64_t return_to = 18446744073709549590LLU;
46058+ uint64_t return_to = 18446744073709549588LLU;
4596646059 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4596746060 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4596846061 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45971,7 +46064,7 @@
4597146064 state.addr = 861504796319285248LLU; // typeu64___
4597246065 break;
4597346066 }
45974- case 18446744073709549590LLU: // 99999999eV'''''''''''''''
46067+ case 18446744073709549588LLU: // 99999999eT'''''''''''''''
4597546068 {
4597646069 {
4597746070 uint64_t arg = 0;
@@ -45996,7 +46089,7 @@
4599646089 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4599746090 }
4599846091 // ACCUMULATE ARGUMENTS - END
45999- uint64_t return_to = 18446744073709549588LLU;
46092+ uint64_t return_to = 18446744073709549586LLU;
4600046093 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4600146094 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4600246095 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46005,7 +46098,7 @@
4600546098 state.addr = 861504796319285248LLU; // typeu64___
4600646099 break;
4600746100 }
46008- case 18446744073709549588LLU: // 99999999eT'''''''''''''''
46101+ case 18446744073709549586LLU: // 99999999eR'''''''''''''''
4600946102 {
4601046103 {
4601146104 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -46025,7 +46118,7 @@
4602546118 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4602646119 }
4602746120 // ACCUMULATE ARGUMENTS - END
46028- uint64_t return_to = 18446744073709549589LLU;
46121+ uint64_t return_to = 18446744073709549587LLU;
4602946122 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4603046123 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4603146124 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46034,7 +46127,7 @@
4603446127 state.addr = 819859607768530944LLU; // resdest___
4603546128 break;
4603646129 }
46037- case 18446744073709549589LLU: // 99999999eU'''''''''''''''
46130+ case 18446744073709549587LLU: // 99999999eS'''''''''''''''
4603846131 {
4603946132 // ACCUMULATE ARGUMENTS - BEGIN
4604046133 {
@@ -46054,7 +46147,7 @@
4605446147 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4605546148 }
4605646149 // ACCUMULATE ARGUMENTS - END
46057- uint64_t return_to = 18446744073709549587LLU;
46150+ uint64_t return_to = 18446744073709549585LLU;
4605846151 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4605946152 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4606046153 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46063,7 +46156,7 @@
4606346156 state.addr = 819857494882385920LLU; // res_u64___
4606446157 break;
4606546158 }
46066- case 18446744073709549587LLU: // 99999999eS'''''''''''''''
46159+ case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
4606746160 {
4606846161 // ACCUMULATE ARGUMENTS - BEGIN
4606946162 {
@@ -46071,7 +46164,7 @@
4607146164 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4607246165 }
4607346166 // ACCUMULATE ARGUMENTS - END
46074- uint64_t return_to = 18446744073709549586LLU;
46167+ uint64_t return_to = 18446744073709549584LLU;
4607546168 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4607646169 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4607746170 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46080,7 +46173,7 @@
4608046173 state.addr = 839519665163075584LLU; // skip______
4608146174 break;
4608246175 }
46083- case 18446744073709549586LLU: // 99999999eR'''''''''''''''
46176+ case 18446744073709549584LLU: // 99999999eP'''''''''''''''
4608446177 {
4608546178 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4608646179 fprintf(stdout, "%s", "\n ");
@@ -46106,7 +46199,7 @@
4610646199 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4610746200 }
4610846201 // ACCUMULATE ARGUMENTS - END
46109- uint64_t return_to = 18446744073709549585LLU;
46202+ uint64_t return_to = 18446744073709549583LLU;
4611046203 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4611146204 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4611246205 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46115,7 +46208,7 @@
4611546208 state.addr = 587881357514113024LLU; // emitpar___
4611646209 break;
4611746210 }
46118- case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
46211+ case 18446744073709549583LLU: // 99999999eO'''''''''''''''
4611946212 {
4612046213 fprintf(stdout, "%s", " = !");
4612146214 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46124,7 +46217,7 @@
4612446217 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4612546218 }
4612646219 // ACCUMULATE ARGUMENTS - END
46127- uint64_t return_to = 18446744073709549584LLU;
46220+ uint64_t return_to = 18446744073709549582LLU;
4612846221 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4612946222 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4613046223 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46133,7 +46226,7 @@
4613346226 state.addr = 839519665163075584LLU; // skip______
4613446227 break;
4613546228 }
46136- case 18446744073709549584LLU: // 99999999eP'''''''''''''''
46229+ case 18446744073709549582LLU: // 99999999eN'''''''''''''''
4613746230 {
4613846231
4613946232 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -46155,7 +46248,7 @@
4615546248 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4615646249 }
4615746250 // ACCUMULATE ARGUMENTS - END
46158- uint64_t return_to = 18446744073709549583LLU;
46251+ uint64_t return_to = 18446744073709549581LLU;
4615946252 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4616046253 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4616146254 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46164,7 +46257,7 @@
4616446257 state.addr = 23446349213393492LLU; // ASSERTINIT
4616546258 break;
4616646259 }
46167- case 18446744073709549583LLU: // 99999999eO'''''''''''''''
46260+ case 18446744073709549581LLU: // 99999999eM'''''''''''''''
4616846261 {
4616946262 {
4617046263 uint64_t arg = 0;
@@ -46243,7 +46336,7 @@
4624346336 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4624446337 }
4624546338 // ACCUMULATE ARGUMENTS - END
46246- uint64_t return_to = 18446744073709549582LLU;
46339+ uint64_t return_to = 18446744073709549580LLU;
4624746340 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4624846341 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4624946342 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46252,7 +46345,7 @@
4625246345 state.addr = 293363126232490310LLU; // PROCVARREF
4625346346 break;
4625446347 }
46255- case 18446744073709549582LLU: // 99999999eN'''''''''''''''
46348+ case 18446744073709549580LLU: // 99999999eL'''''''''''''''
4625646349 {
4625746350 // variable u64 initialize goes out of scope
4625846351 // emitted destructur for type u64
@@ -46273,7 +46366,7 @@
4627346366 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4627446367 }
4627546368 // ACCUMULATE ARGUMENTS - END
46276- uint64_t return_to = 18446744073709549581LLU;
46369+ uint64_t return_to = 18446744073709549579LLU;
4627746370 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4627846371 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4627946372 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46282,7 +46375,7 @@
4628246375 state.addr = 517555565476695680LLU; // assertu64_
4628346376 break;
4628446377 }
46285- case 18446744073709549581LLU: // 99999999eM'''''''''''''''
46378+ case 18446744073709549579LLU: // 99999999eK'''''''''''''''
4628646379 {
4628746380 // ACCUMULATE ARGUMENTS - BEGIN
4628846381 {
@@ -46290,7 +46383,7 @@
4629046383 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4629146384 }
4629246385 // ACCUMULATE ARGUMENTS - END
46293- uint64_t return_to = 18446744073709549580LLU;
46386+ uint64_t return_to = 18446744073709549578LLU;
4629446387 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4629546388 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4629646389 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46299,7 +46392,7 @@
4629946392 state.addr = 839519665163075584LLU; // skip______
4630046393 break;
4630146394 }
46302- case 18446744073709549580LLU: // 99999999eL'''''''''''''''
46395+ case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
4630346396 {
4630446397 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4630546398 fprintf(stdout, "%s", ";");
@@ -46311,7 +46404,7 @@
4631146404 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4631246405 }
4631346406 // ACCUMULATE ARGUMENTS - END
46314- uint64_t return_to = 18446744073709549579LLU;
46407+ uint64_t return_to = 18446744073709549577LLU;
4631546408 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4631646409 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4631746410 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46320,7 +46413,7 @@
4632046413 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4632146414 break;
4632246415 }
46323- case 18446744073709549579LLU: // 99999999eK'''''''''''''''
46416+ case 18446744073709549577LLU: // 99999999eI'''''''''''''''
4632446417 {
4632546418 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4632646419 // variable type______ type______ goes out of scope
@@ -46331,7 +46424,7 @@
4633146424 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4633246425 }
4633346426 // ACCUMULATE ARGUMENTS - END
46334- uint64_t return_to = 18446744073709549578LLU;
46427+ uint64_t return_to = 18446744073709549576LLU;
4633546428 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4633646429 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4633746430 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46340,7 +46433,7 @@
4634046433 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4634146434 break;
4634246435 }
46343- case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
46436+ case 18446744073709549576LLU: // 99999999eH'''''''''''''''
4634446437 {
4634546438 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4634646439 // variable u64 mutable___ goes out of scope
@@ -46352,10 +46445,10 @@
4635246445 // variable u64 id________ goes out of scope
4635346446 // emitted destructur for type u64
4635446447 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
46355- state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
46448+ state.addr = 18446744073709549589LLU; // 99999999eU'''''''''''''''
4635646449 break;
4635746450 }
46358- case 18446744073709549592LLU: // 99999999eX'''''''''''''''
46451+ case 18446744073709549590LLU: // 99999999eV'''''''''''''''
4635946452 {
4636046453
4636146454 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543416397824;
@@ -46366,11 +46459,11 @@
4636646459 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4636746460 }
4636846461 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46369- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549577LLU : 18446744073709549576LLU;
46462+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549575LLU : 18446744073709549574LLU;
4637046463 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4637146464 break;
4637246465 }
46373- case 18446744073709549577LLU: // 99999999eI'''''''''''''''
46466+ case 18446744073709549575LLU: // 99999999eG'''''''''''''''
4637446467 {
4637546468 {
4637646469 uint64_t arg = 0;
@@ -46397,7 +46490,7 @@
4639746490 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4639846491 }
4639946492 // ACCUMULATE ARGUMENTS - END
46400- uint64_t return_to = 18446744073709549574LLU;
46493+ uint64_t return_to = 18446744073709549572LLU;
4640146494 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4640246495 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4640346496 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46406,7 +46499,7 @@
4640646499 state.addr = 861504796319285248LLU; // typeu64___
4640746500 break;
4640846501 }
46409- case 18446744073709549574LLU: // 99999999eF'''''''''''''''
46502+ case 18446744073709549572LLU: // 99999999eD'''''''''''''''
4641046503 {
4641146504 {
4641246505 uint64_t arg = 0;
@@ -46431,7 +46524,7 @@
4643146524 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4643246525 }
4643346526 // ACCUMULATE ARGUMENTS - END
46434- uint64_t return_to = 18446744073709549572LLU;
46527+ uint64_t return_to = 18446744073709549570LLU;
4643546528 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4643646529 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4643746530 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46440,7 +46533,7 @@
4644046533 state.addr = 861504796319285248LLU; // typeu64___
4644146534 break;
4644246535 }
46443- case 18446744073709549572LLU: // 99999999eD'''''''''''''''
46536+ case 18446744073709549570LLU: // 99999999eB'''''''''''''''
4644446537 {
4644546538 {
4644646539 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -46460,7 +46553,7 @@
4646046553 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4646146554 }
4646246555 // ACCUMULATE ARGUMENTS - END
46463- uint64_t return_to = 18446744073709549573LLU;
46556+ uint64_t return_to = 18446744073709549571LLU;
4646446557 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4646546558 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4646646559 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46469,7 +46562,7 @@
4646946562 state.addr = 819859607768530944LLU; // resdest___
4647046563 break;
4647146564 }
46472- case 18446744073709549573LLU: // 99999999eE'''''''''''''''
46565+ case 18446744073709549571LLU: // 99999999eC'''''''''''''''
4647346566 {
4647446567 // ACCUMULATE ARGUMENTS - BEGIN
4647546568 {
@@ -46489,7 +46582,7 @@
4648946582 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4649046583 }
4649146584 // ACCUMULATE ARGUMENTS - END
46492- uint64_t return_to = 18446744073709549571LLU;
46585+ uint64_t return_to = 18446744073709549569LLU;
4649346586 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4649446587 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4649546588 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46498,7 +46591,7 @@
4649846591 state.addr = 819857494882385920LLU; // res_u64___
4649946592 break;
4650046593 }
46501- case 18446744073709549571LLU: // 99999999eC'''''''''''''''
46594+ case 18446744073709549569LLU: // 99999999eA'''''''''''''''
4650246595 {
4650346596 // ACCUMULATE ARGUMENTS - BEGIN
4650446597 {
@@ -46506,7 +46599,7 @@
4650646599 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4650746600 }
4650846601 // ACCUMULATE ARGUMENTS - END
46509- uint64_t return_to = 18446744073709549570LLU;
46602+ uint64_t return_to = 18446744073709549568LLU;
4651046603 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4651146604 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4651246605 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46515,7 +46608,7 @@
4651546608 state.addr = 839519665163075584LLU; // skip______
4651646609 break;
4651746610 }
46518- case 18446744073709549570LLU: // 99999999eB'''''''''''''''
46611+ case 18446744073709549568LLU: // 99999999e_'''''''''''''''
4651946612 {
4652046613 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4652146614 fprintf(stdout, "%s", "\n ");
@@ -46541,7 +46634,7 @@
4654146634 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4654246635 }
4654346636 // ACCUMULATE ARGUMENTS - END
46544- uint64_t return_to = 18446744073709549569LLU;
46637+ uint64_t return_to = 18446744073709549567LLU;
4654546638 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4654646639 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4654746640 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46550,7 +46643,7 @@
4655046643 state.addr = 587881357514113024LLU; // emitpar___
4655146644 break;
4655246645 }
46553- case 18446744073709549569LLU: // 99999999eA'''''''''''''''
46646+ case 18446744073709549567LLU: // 99999999d9'''''''''''''''
4655446647 {
4655546648 fprintf(stdout, "%s", " = parseid(&");
4655646649 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46559,7 +46652,7 @@
4655946652 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4656046653 }
4656146654 // ACCUMULATE ARGUMENTS - END
46562- uint64_t return_to = 18446744073709549568LLU;
46655+ uint64_t return_to = 18446744073709549566LLU;
4656346656 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4656446657 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4656546658 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46568,7 +46661,7 @@
4656846661 state.addr = 839519665163075584LLU; // skip______
4656946662 break;
4657046663 }
46571- case 18446744073709549568LLU: // 99999999e_'''''''''''''''
46664+ case 18446744073709549566LLU: // 99999999d8'''''''''''''''
4657246665 {
4657346666
4657446667 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -46590,7 +46683,7 @@
4659046683 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4659146684 }
4659246685 // ACCUMULATE ARGUMENTS - END
46593- uint64_t return_to = 18446744073709549567LLU;
46686+ uint64_t return_to = 18446744073709549565LLU;
4659446687 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4659546688 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4659646689 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46599,7 +46692,7 @@
4659946692 state.addr = 23446349213393492LLU; // ASSERTINIT
4660046693 break;
4660146694 }
46602- case 18446744073709549567LLU: // 99999999d9'''''''''''''''
46695+ case 18446744073709549565LLU: // 99999999d7'''''''''''''''
4660346696 {
4660446697 {
4660546698 uint64_t arg = 0;
@@ -46678,7 +46771,7 @@
4667846771 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4667946772 }
4668046773 // ACCUMULATE ARGUMENTS - END
46681- uint64_t return_to = 18446744073709549566LLU;
46774+ uint64_t return_to = 18446744073709549564LLU;
4668246775 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4668346776 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4668446777 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46687,7 +46780,7 @@
4668746780 state.addr = 293363126232490310LLU; // PROCVARREF
4668846781 break;
4668946782 }
46690- case 18446744073709549566LLU: // 99999999d8'''''''''''''''
46783+ case 18446744073709549564LLU: // 99999999d6'''''''''''''''
4669146784 {
4669246785 // variable u64 initialize goes out of scope
4669346786 // emitted destructur for type u64
@@ -46708,7 +46801,7 @@
4670846801 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4670946802 }
4671046803 // ACCUMULATE ARGUMENTS - END
46711- uint64_t return_to = 18446744073709549565LLU;
46804+ uint64_t return_to = 18446744073709549563LLU;
4671246805 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4671346806 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4671446807 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46717,7 +46810,7 @@
4671746810 state.addr = 517555565476695680LLU; // assertu64_
4671846811 break;
4671946812 }
46720- case 18446744073709549565LLU: // 99999999d7'''''''''''''''
46813+ case 18446744073709549563LLU: // 99999999d5'''''''''''''''
4672146814 {
4672246815 fprintf(stdout, "%s", ");");
4672346816 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46726,7 +46819,7 @@
4672646819 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4672746820 }
4672846821 // ACCUMULATE ARGUMENTS - END
46729- uint64_t return_to = 18446744073709549564LLU;
46822+ uint64_t return_to = 18446744073709549562LLU;
4673046823 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4673146824 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4673246825 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46735,7 +46828,7 @@
4673546828 state.addr = 839519665163075584LLU; // skip______
4673646829 break;
4673746830 }
46738- case 18446744073709549564LLU: // 99999999d6'''''''''''''''
46831+ case 18446744073709549562LLU: // 99999999d4'''''''''''''''
4673946832 {
4674046833 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4674146834 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46748,7 +46841,7 @@
4674846841 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4674946842 }
4675046843 // ACCUMULATE ARGUMENTS - END
46751- uint64_t return_to = 18446744073709549563LLU;
46844+ uint64_t return_to = 18446744073709549561LLU;
4675246845 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4675346846 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4675446847 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46757,7 +46850,7 @@
4675746850 state.addr = 517555565476695680LLU; // assertu64_
4675846851 break;
4675946852 }
46760- case 18446744073709549563LLU: // 99999999d5'''''''''''''''
46853+ case 18446744073709549561LLU: // 99999999d3'''''''''''''''
4676146854 {
4676246855 {
4676346856 uint64_t arg = 0;
@@ -46786,7 +46879,7 @@
4678646879 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4678746880 }
4678846881 // ACCUMULATE ARGUMENTS - END
46789- uint64_t return_to = 18446744073709549562LLU;
46882+ uint64_t return_to = 18446744073709549560LLU;
4679046883 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4679146884 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4679246885 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46795,7 +46888,7 @@
4679546888 state.addr = 734295421765213120LLU; // mutassert_
4679646889 break;
4679746890 }
46798- case 18446744073709549562LLU: // 99999999d4'''''''''''''''
46891+ case 18446744073709549560LLU: // 99999999d2'''''''''''''''
4679946892 {
4680046893 // variable u64 parnr_____ goes out of scope
4680146894 // emitted destructur for type u64
@@ -46808,7 +46901,7 @@
4680846901 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4680946902 }
4681046903 // ACCUMULATE ARGUMENTS - END
46811- uint64_t return_to = 18446744073709549561LLU;
46904+ uint64_t return_to = 18446744073709549559LLU;
4681246905 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4681346906 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4681446907 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46817,7 +46910,7 @@
4681746910 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4681846911 break;
4681946912 }
46820- case 18446744073709549561LLU: // 99999999d3'''''''''''''''
46913+ case 18446744073709549559LLU: // 99999999d1'''''''''''''''
4682146914 {
4682246915 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4682346916 // variable type______ type______ goes out of scope
@@ -46828,7 +46921,7 @@
4682846921 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4682946922 }
4683046923 // ACCUMULATE ARGUMENTS - END
46831- uint64_t return_to = 18446744073709549560LLU;
46924+ uint64_t return_to = 18446744073709549558LLU;
4683246925 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4683346926 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4683446927 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46837,7 +46930,7 @@
4683746930 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4683846931 break;
4683946932 }
46840- case 18446744073709549560LLU: // 99999999d2'''''''''''''''
46933+ case 18446744073709549558LLU: // 99999999d0'''''''''''''''
4684146934 {
4684246935 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4684346936 // variable u64 mutable___ goes out of scope
@@ -46849,10 +46942,10 @@
4684946942 // variable u64 id________ goes out of scope
4685046943 // emitted destructur for type u64
4685146944 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
46852- state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
46945+ state.addr = 18446744073709549573LLU; // 99999999eE'''''''''''''''
4685346946 break;
4685446947 }
46855- case 18446744073709549576LLU: // 99999999eH'''''''''''''''
46948+ case 18446744073709549574LLU: // 99999999eF'''''''''''''''
4685646949 {
4685746950
4685846951 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543503953920;
@@ -46863,11 +46956,11 @@
4686346956 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4686446957 }
4686546958 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46866- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549559LLU : 18446744073709549558LLU;
46959+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549557LLU : 18446744073709549556LLU;
4686746960 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4686846961 break;
4686946962 }
46870- case 18446744073709549559LLU: // 99999999d1'''''''''''''''
46963+ case 18446744073709549557LLU: // 99999999dz'''''''''''''''
4687146964 {
4687246965 {
4687346966 uint64_t arg = 0;
@@ -46894,7 +46987,7 @@
4689446987 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4689546988 }
4689646989 // ACCUMULATE ARGUMENTS - END
46897- uint64_t return_to = 18446744073709549556LLU;
46990+ uint64_t return_to = 18446744073709549554LLU;
4689846991 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4689946992 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4690046993 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46903,7 +46996,7 @@
4690346996 state.addr = 861504796319285248LLU; // typeu64___
4690446997 break;
4690546998 }
46906- case 18446744073709549556LLU: // 99999999dy'''''''''''''''
46999+ case 18446744073709549554LLU: // 99999999dw'''''''''''''''
4690747000 {
4690847001 {
4690947002 uint64_t arg = 0;
@@ -46928,7 +47021,7 @@
4692847021 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4692947022 }
4693047023 // ACCUMULATE ARGUMENTS - END
46931- uint64_t return_to = 18446744073709549554LLU;
47024+ uint64_t return_to = 18446744073709549552LLU;
4693247025 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4693347026 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4693447027 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46937,7 +47030,7 @@
4693747030 state.addr = 861504796319285248LLU; // typeu64___
4693847031 break;
4693947032 }
46940- case 18446744073709549554LLU: // 99999999dw'''''''''''''''
47033+ case 18446744073709549552LLU: // 99999999du'''''''''''''''
4694147034 {
4694247035 {
4694347036 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -46957,7 +47050,7 @@
4695747050 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4695847051 }
4695947052 // ACCUMULATE ARGUMENTS - END
46960- uint64_t return_to = 18446744073709549555LLU;
47053+ uint64_t return_to = 18446744073709549553LLU;
4696147054 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4696247055 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4696347056 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46966,7 +47059,7 @@
4696647059 state.addr = 819859607768530944LLU; // resdest___
4696747060 break;
4696847061 }
46969- case 18446744073709549555LLU: // 99999999dx'''''''''''''''
47062+ case 18446744073709549553LLU: // 99999999dv'''''''''''''''
4697047063 {
4697147064 // ACCUMULATE ARGUMENTS - BEGIN
4697247065 {
@@ -46986,7 +47079,7 @@
4698647079 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4698747080 }
4698847081 // ACCUMULATE ARGUMENTS - END
46989- uint64_t return_to = 18446744073709549553LLU;
47082+ uint64_t return_to = 18446744073709549551LLU;
4699047083 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4699147084 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4699247085 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46995,7 +47088,7 @@
4699547088 state.addr = 819857494882385920LLU; // res_u64___
4699647089 break;
4699747090 }
46998- case 18446744073709549553LLU: // 99999999dv'''''''''''''''
47091+ case 18446744073709549551LLU: // 99999999dt'''''''''''''''
4699947092 {
4700047093 // ACCUMULATE ARGUMENTS - BEGIN
4700147094 {
@@ -47003,7 +47096,7 @@
4700347096 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4700447097 }
4700547098 // ACCUMULATE ARGUMENTS - END
47006- uint64_t return_to = 18446744073709549552LLU;
47099+ uint64_t return_to = 18446744073709549550LLU;
4700747100 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4700847101 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4700947102 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47012,7 +47105,7 @@
4701247105 state.addr = 839519665163075584LLU; // skip______
4701347106 break;
4701447107 }
47015- case 18446744073709549552LLU: // 99999999du'''''''''''''''
47108+ case 18446744073709549550LLU: // 99999999ds'''''''''''''''
4701647109 {
4701747110 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4701847111 fprintf(stdout, "%s", "\n ");
@@ -47038,7 +47131,7 @@
4703847131 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4703947132 }
4704047133 // ACCUMULATE ARGUMENTS - END
47041- uint64_t return_to = 18446744073709549551LLU;
47134+ uint64_t return_to = 18446744073709549549LLU;
4704247135 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4704347136 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4704447137 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47047,7 +47140,7 @@
4704747140 state.addr = 587881357514113024LLU; // emitpar___
4704847141 break;
4704947142 }
47050- case 18446744073709549551LLU: // 99999999dt'''''''''''''''
47143+ case 18446744073709549549LLU: // 99999999dr'''''''''''''''
4705147144 {
4705247145 fprintf(stdout, "%s", " = parsenr(&");
4705347146 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47056,7 +47149,7 @@
4705647149 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4705747150 }
4705847151 // ACCUMULATE ARGUMENTS - END
47059- uint64_t return_to = 18446744073709549550LLU;
47152+ uint64_t return_to = 18446744073709549548LLU;
4706047153 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4706147154 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4706247155 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47065,7 +47158,7 @@
4706547158 state.addr = 839519665163075584LLU; // skip______
4706647159 break;
4706747160 }
47068- case 18446744073709549550LLU: // 99999999ds'''''''''''''''
47161+ case 18446744073709549548LLU: // 99999999dq'''''''''''''''
4706947162 {
4707047163
4707147164 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -47087,7 +47180,7 @@
4708747180 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4708847181 }
4708947182 // ACCUMULATE ARGUMENTS - END
47090- uint64_t return_to = 18446744073709549549LLU;
47183+ uint64_t return_to = 18446744073709549547LLU;
4709147184 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4709247185 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4709347186 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47096,7 +47189,7 @@
4709647189 state.addr = 23446349213393492LLU; // ASSERTINIT
4709747190 break;
4709847191 }
47099- case 18446744073709549549LLU: // 99999999dr'''''''''''''''
47192+ case 18446744073709549547LLU: // 99999999dp'''''''''''''''
4710047193 {
4710147194 {
4710247195 uint64_t arg = 0;
@@ -47175,7 +47268,7 @@
4717547268 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4717647269 }
4717747270 // ACCUMULATE ARGUMENTS - END
47178- uint64_t return_to = 18446744073709549548LLU;
47271+ uint64_t return_to = 18446744073709549546LLU;
4717947272 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4718047273 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4718147274 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47184,7 +47277,7 @@
4718447277 state.addr = 293363126232490310LLU; // PROCVARREF
4718547278 break;
4718647279 }
47187- case 18446744073709549548LLU: // 99999999dq'''''''''''''''
47280+ case 18446744073709549546LLU: // 99999999do'''''''''''''''
4718847281 {
4718947282 // variable u64 initialize goes out of scope
4719047283 // emitted destructur for type u64
@@ -47205,7 +47298,7 @@
4720547298 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4720647299 }
4720747300 // ACCUMULATE ARGUMENTS - END
47208- uint64_t return_to = 18446744073709549547LLU;
47301+ uint64_t return_to = 18446744073709549545LLU;
4720947302 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4721047303 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4721147304 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47214,7 +47307,7 @@
4721447307 state.addr = 517555565476695680LLU; // assertu64_
4721547308 break;
4721647309 }
47217- case 18446744073709549547LLU: // 99999999dp'''''''''''''''
47310+ case 18446744073709549545LLU: // 99999999dn'''''''''''''''
4721847311 {
4721947312 fprintf(stdout, "%s", ");");
4722047313 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47223,7 +47316,7 @@
4722347316 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4722447317 }
4722547318 // ACCUMULATE ARGUMENTS - END
47226- uint64_t return_to = 18446744073709549546LLU;
47319+ uint64_t return_to = 18446744073709549544LLU;
4722747320 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4722847321 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4722947322 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47232,7 +47325,7 @@
4723247325 state.addr = 839519665163075584LLU; // skip______
4723347326 break;
4723447327 }
47235- case 18446744073709549546LLU: // 99999999do'''''''''''''''
47328+ case 18446744073709549544LLU: // 99999999dm'''''''''''''''
4723647329 {
4723747330 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4723847331 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47245,7 +47338,7 @@
4724547338 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4724647339 }
4724747340 // ACCUMULATE ARGUMENTS - END
47248- uint64_t return_to = 18446744073709549545LLU;
47341+ uint64_t return_to = 18446744073709549543LLU;
4724947342 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4725047343 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4725147344 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47254,7 +47347,7 @@
4725447347 state.addr = 517555565476695680LLU; // assertu64_
4725547348 break;
4725647349 }
47257- case 18446744073709549545LLU: // 99999999dn'''''''''''''''
47350+ case 18446744073709549543LLU: // 99999999dl'''''''''''''''
4725847351 {
4725947352 {
4726047353 uint64_t arg = 0;
@@ -47283,7 +47376,7 @@
4728347376 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4728447377 }
4728547378 // ACCUMULATE ARGUMENTS - END
47286- uint64_t return_to = 18446744073709549544LLU;
47379+ uint64_t return_to = 18446744073709549542LLU;
4728747380 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4728847381 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4728947382 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47292,7 +47385,7 @@
4729247385 state.addr = 734295421765213120LLU; // mutassert_
4729347386 break;
4729447387 }
47295- case 18446744073709549544LLU: // 99999999dm'''''''''''''''
47388+ case 18446744073709549542LLU: // 99999999dk'''''''''''''''
4729647389 {
4729747390 // variable u64 parnr_____ goes out of scope
4729847391 // emitted destructur for type u64
@@ -47305,7 +47398,7 @@
4730547398 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4730647399 }
4730747400 // ACCUMULATE ARGUMENTS - END
47308- uint64_t return_to = 18446744073709549543LLU;
47401+ uint64_t return_to = 18446744073709549541LLU;
4730947402 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4731047403 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4731147404 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47314,7 +47407,7 @@
4731447407 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4731547408 break;
4731647409 }
47317- case 18446744073709549543LLU: // 99999999dl'''''''''''''''
47410+ case 18446744073709549541LLU: // 99999999dj'''''''''''''''
4731847411 {
4731947412 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4732047413 // variable type______ type______ goes out of scope
@@ -47325,7 +47418,7 @@
4732547418 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4732647419 }
4732747420 // ACCUMULATE ARGUMENTS - END
47328- uint64_t return_to = 18446744073709549542LLU;
47421+ uint64_t return_to = 18446744073709549540LLU;
4732947422 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4733047423 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4733147424 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47334,7 +47427,7 @@
4733447427 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4733547428 break;
4733647429 }
47337- case 18446744073709549542LLU: // 99999999dk'''''''''''''''
47430+ case 18446744073709549540LLU: // 99999999di'''''''''''''''
4733847431 {
4733947432 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4734047433 // variable u64 mutable___ goes out of scope
@@ -47346,10 +47439,10 @@
4734647439 // variable u64 id________ goes out of scope
4734747440 // emitted destructur for type u64
4734847441 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
47349- state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
47442+ state.addr = 18446744073709549555LLU; // 99999999dx'''''''''''''''
4735047443 break;
4735147444 }
47352- case 18446744073709549558LLU: // 99999999d0'''''''''''''''
47445+ case 18446744073709549556LLU: // 99999999dy'''''''''''''''
4735347446 {
4735447447
4735547448 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750596285075554304;
@@ -47360,11 +47453,11 @@
4736047453 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4736147454 }
4736247455 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47363- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549541LLU : 18446744073709549540LLU;
47456+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549539LLU : 18446744073709549538LLU;
4736447457 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4736547458 break;
4736647459 }
47367- case 18446744073709549541LLU: // 99999999dj'''''''''''''''
47460+ case 18446744073709549539LLU: // 99999999dh'''''''''''''''
4736847461 {
4736947462 {
4737047463 uint64_t arg = 0;
@@ -47391,7 +47484,7 @@
4739147484 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4739247485 }
4739347486 // ACCUMULATE ARGUMENTS - END
47394- uint64_t return_to = 18446744073709549538LLU;
47487+ uint64_t return_to = 18446744073709549536LLU;
4739547488 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4739647489 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4739747490 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47400,7 +47493,7 @@
4740047493 state.addr = 861504796319285248LLU; // typeu64___
4740147494 break;
4740247495 }
47403- case 18446744073709549538LLU: // 99999999dg'''''''''''''''
47496+ case 18446744073709549536LLU: // 99999999de'''''''''''''''
4740447497 {
4740547498 {
4740647499 uint64_t arg = 0;
@@ -47425,7 +47518,7 @@
4742547518 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4742647519 }
4742747520 // ACCUMULATE ARGUMENTS - END
47428- uint64_t return_to = 18446744073709549536LLU;
47521+ uint64_t return_to = 18446744073709549534LLU;
4742947522 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4743047523 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4743147524 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47434,7 +47527,7 @@
4743447527 state.addr = 861504796319285248LLU; // typeu64___
4743547528 break;
4743647529 }
47437- case 18446744073709549536LLU: // 99999999de'''''''''''''''
47530+ case 18446744073709549534LLU: // 99999999dc'''''''''''''''
4743847531 {
4743947532 {
4744047533 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -47454,7 +47547,7 @@
4745447547 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4745547548 }
4745647549 // ACCUMULATE ARGUMENTS - END
47457- uint64_t return_to = 18446744073709549537LLU;
47550+ uint64_t return_to = 18446744073709549535LLU;
4745847551 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4745947552 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4746047553 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47463,7 +47556,7 @@
4746347556 state.addr = 819859607768530944LLU; // resdest___
4746447557 break;
4746547558 }
47466- case 18446744073709549537LLU: // 99999999df'''''''''''''''
47559+ case 18446744073709549535LLU: // 99999999dd'''''''''''''''
4746747560 {
4746847561 // ACCUMULATE ARGUMENTS - BEGIN
4746947562 {
@@ -47483,7 +47576,7 @@
4748347576 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4748447577 }
4748547578 // ACCUMULATE ARGUMENTS - END
47486- uint64_t return_to = 18446744073709549535LLU;
47579+ uint64_t return_to = 18446744073709549533LLU;
4748747580 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4748847581 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4748947582 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47492,7 +47585,7 @@
4749247585 state.addr = 819857494882385920LLU; // res_u64___
4749347586 break;
4749447587 }
47495- case 18446744073709549535LLU: // 99999999dd'''''''''''''''
47588+ case 18446744073709549533LLU: // 99999999db'''''''''''''''
4749647589 {
4749747590 // ACCUMULATE ARGUMENTS - BEGIN
4749847591 {
@@ -47500,7 +47593,7 @@
4750047593 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4750147594 }
4750247595 // ACCUMULATE ARGUMENTS - END
47503- uint64_t return_to = 18446744073709549534LLU;
47596+ uint64_t return_to = 18446744073709549532LLU;
4750447597 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4750547598 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4750647599 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47509,7 +47602,7 @@
4750947602 state.addr = 839519665163075584LLU; // skip______
4751047603 break;
4751147604 }
47512- case 18446744073709549534LLU: // 99999999dc'''''''''''''''
47605+ case 18446744073709549532LLU: // 99999999da'''''''''''''''
4751347606 {
4751447607 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4751547608 fprintf(stdout, "%s", "\n ");
@@ -47535,7 +47628,7 @@
4753547628 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4753647629 }
4753747630 // ACCUMULATE ARGUMENTS - END
47538- uint64_t return_to = 18446744073709549533LLU;
47631+ uint64_t return_to = 18446744073709549531LLU;
4753947632 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4754047633 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4754147634 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47544,7 +47637,7 @@
4754447637 state.addr = 587881357514113024LLU; // emitpar___
4754547638 break;
4754647639 }
47547- case 18446744073709549533LLU: // 99999999db'''''''''''''''
47640+ case 18446744073709549531LLU: // 99999999d$'''''''''''''''
4754847641 {
4754947642 fprintf(stdout, "%s", " = !!");
4755047643 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47553,7 +47646,7 @@
4755347646 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4755447647 }
4755547648 // ACCUMULATE ARGUMENTS - END
47556- uint64_t return_to = 18446744073709549532LLU;
47649+ uint64_t return_to = 18446744073709549530LLU;
4755747650 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4755847651 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4755947652 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47562,7 +47655,7 @@
4756247655 state.addr = 839519665163075584LLU; // skip______
4756347656 break;
4756447657 }
47565- case 18446744073709549532LLU: // 99999999da'''''''''''''''
47658+ case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
4756647659 {
4756747660
4756847661 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -47584,7 +47677,7 @@
4758447677 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4758547678 }
4758647679 // ACCUMULATE ARGUMENTS - END
47587- uint64_t return_to = 18446744073709549531LLU;
47680+ uint64_t return_to = 18446744073709549529LLU;
4758847681 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4758947682 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4759047683 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47593,7 +47686,7 @@
4759347686 state.addr = 23446349213393492LLU; // ASSERTINIT
4759447687 break;
4759547688 }
47596- case 18446744073709549531LLU: // 99999999d$'''''''''''''''
47689+ case 18446744073709549529LLU: // 99999999dY'''''''''''''''
4759747690 {
4759847691 {
4759947692 uint64_t arg = 0;
@@ -47672,7 +47765,7 @@
4767247765 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4767347766 }
4767447767 // ACCUMULATE ARGUMENTS - END
47675- uint64_t return_to = 18446744073709549530LLU;
47768+ uint64_t return_to = 18446744073709549528LLU;
4767647769 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4767747770 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4767847771 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47681,7 +47774,7 @@
4768147774 state.addr = 293363126232490310LLU; // PROCVARREF
4768247775 break;
4768347776 }
47684- case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
47777+ case 18446744073709549528LLU: // 99999999dX'''''''''''''''
4768547778 {
4768647779 // variable u64 initialize goes out of scope
4768747780 // emitted destructur for type u64
@@ -47698,7 +47791,7 @@
4769847791 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4769947792 }
4770047793 // ACCUMULATE ARGUMENTS - END
47701- uint64_t return_to = 18446744073709549529LLU;
47794+ uint64_t return_to = 18446744073709549527LLU;
4770247795 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4770347796 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4770447797 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47707,7 +47800,7 @@
4770747800 state.addr = 839519665163075584LLU; // skip______
4770847801 break;
4770947802 }
47710- case 18446744073709549529LLU: // 99999999dY'''''''''''''''
47803+ case 18446744073709549527LLU: // 99999999dW'''''''''''''''
4771147804 {
4771247805 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4771347806 fprintf(stdout, "%s", ";");
@@ -47719,7 +47812,7 @@
4771947812 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4772047813 }
4772147814 // ACCUMULATE ARGUMENTS - END
47722- uint64_t return_to = 18446744073709549528LLU;
47815+ uint64_t return_to = 18446744073709549526LLU;
4772347816 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4772447817 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4772547818 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47728,7 +47821,7 @@
4772847821 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4772947822 break;
4773047823 }
47731- case 18446744073709549528LLU: // 99999999dX'''''''''''''''
47824+ case 18446744073709549526LLU: // 99999999dV'''''''''''''''
4773247825 {
4773347826 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4773447827 // variable type______ type______ goes out of scope
@@ -47739,7 +47832,7 @@
4773947832 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4774047833 }
4774147834 // ACCUMULATE ARGUMENTS - END
47742- uint64_t return_to = 18446744073709549527LLU;
47835+ uint64_t return_to = 18446744073709549525LLU;
4774347836 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4774447837 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4774547838 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47748,7 +47841,7 @@
4774847841 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4774947842 break;
4775047843 }
47751- case 18446744073709549527LLU: // 99999999dW'''''''''''''''
47844+ case 18446744073709549525LLU: // 99999999dU'''''''''''''''
4775247845 {
4775347846 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4775447847 // variable u64 mutable___ goes out of scope
@@ -47760,10 +47853,10 @@
4776047853 // variable u64 id________ goes out of scope
4776147854 // emitted destructur for type u64
4776247855 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
47763- state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
47856+ state.addr = 18446744073709549537LLU; // 99999999df'''''''''''''''
4776447857 break;
4776547858 }
47766- case 18446744073709549540LLU: // 99999999di'''''''''''''''
47859+ case 18446744073709549538LLU: // 99999999dg'''''''''''''''
4776747860 {
4776847861
4776947862 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 839030726086098944;
@@ -47774,11 +47867,11 @@
4777447867 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4777547868 }
4777647869 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47777- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549526LLU : 18446744073709549525LLU;
47870+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549524LLU : 18446744073709549523LLU;
4777847871 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4777947872 break;
4778047873 }
47781- case 18446744073709549526LLU: // 99999999dV'''''''''''''''
47874+ case 18446744073709549524LLU: // 99999999dT'''''''''''''''
4778247875 {
4778347876 {
4778447877 uint64_t arg = 0;
@@ -47803,7 +47896,7 @@
4780347896 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4780447897 }
4780547898 // ACCUMULATE ARGUMENTS - END
47806- uint64_t return_to = 18446744073709549522LLU;
47899+ uint64_t return_to = 18446744073709549520LLU;
4780747900 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4780847901 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4780947902 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47812,7 +47905,7 @@
4781247905 state.addr = 861504796319285248LLU; // typeu64___
4781347906 break;
4781447907 }
47815- case 18446744073709549522LLU: // 99999999dR'''''''''''''''
47908+ case 18446744073709549520LLU: // 99999999dP'''''''''''''''
4781647909 {
4781747910 {
4781847911 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -47832,7 +47925,7 @@
4783247925 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4783347926 }
4783447927 // ACCUMULATE ARGUMENTS - END
47835- uint64_t return_to = 18446744073709549523LLU;
47928+ uint64_t return_to = 18446744073709549521LLU;
4783647929 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4783747930 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4783847931 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47841,7 +47934,7 @@
4784147934 state.addr = 819859607768530944LLU; // resdest___
4784247935 break;
4784347936 }
47844- case 18446744073709549523LLU: // 99999999dS'''''''''''''''
47937+ case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
4784547938 {
4784647939 // ACCUMULATE ARGUMENTS - BEGIN
4784747940 {
@@ -47861,7 +47954,7 @@
4786147954 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4786247955 }
4786347956 // ACCUMULATE ARGUMENTS - END
47864- uint64_t return_to = 18446744073709549521LLU;
47957+ uint64_t return_to = 18446744073709549519LLU;
4786547958 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4786647959 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4786747960 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47870,7 +47963,7 @@
4787047963 state.addr = 819857494882385920LLU; // res_u64___
4787147964 break;
4787247965 }
47873- case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
47966+ case 18446744073709549519LLU: // 99999999dO'''''''''''''''
4787447967 {
4787547968 // ACCUMULATE ARGUMENTS - BEGIN
4787647969 {
@@ -47878,7 +47971,7 @@
4787847971 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4787947972 }
4788047973 // ACCUMULATE ARGUMENTS - END
47881- uint64_t return_to = 18446744073709549520LLU;
47974+ uint64_t return_to = 18446744073709549518LLU;
4788247975 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4788347976 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4788447977 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47887,7 +47980,7 @@
4788747980 state.addr = 839519665163075584LLU; // skip______
4788847981 break;
4788947982 }
47890- case 18446744073709549520LLU: // 99999999dP'''''''''''''''
47983+ case 18446744073709549518LLU: // 99999999dN'''''''''''''''
4789147984 {
4789247985 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4789347986 fprintf(stdout, "%s", "\n list_size(heap.data, &");
@@ -47913,7 +48006,7 @@
4791348006 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4791448007 }
4791548008 // ACCUMULATE ARGUMENTS - END
47916- uint64_t return_to = 18446744073709549519LLU;
48009+ uint64_t return_to = 18446744073709549517LLU;
4791748010 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4791848011 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4791948012 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47922,7 +48015,7 @@
4792248015 state.addr = 587881357514113024LLU; // emitpar___
4792348016 break;
4792448017 }
47925- case 18446744073709549519LLU: // 99999999dO'''''''''''''''
48018+ case 18446744073709549517LLU: // 99999999dM'''''''''''''''
4792648019 {
4792748020 fprintf(stdout, "%s", ", ");
4792848021 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47931,7 +48024,7 @@
4793148024 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4793248025 }
4793348026 // ACCUMULATE ARGUMENTS - END
47934- uint64_t return_to = 18446744073709549518LLU;
48027+ uint64_t return_to = 18446744073709549516LLU;
4793548028 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4793648029 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4793748030 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47940,7 +48033,7 @@
4794048033 state.addr = 839519665163075584LLU; // skip______
4794148034 break;
4794248035 }
47943- case 18446744073709549518LLU: // 99999999dN'''''''''''''''
48036+ case 18446744073709549516LLU: // 99999999dL'''''''''''''''
4794448037 {
4794548038 {
4794648039 uint64_t arg = 0;
@@ -47952,7 +48045,7 @@
4795248045 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4795348046 }
4795448047 // ACCUMULATE ARGUMENTS - END
47955- uint64_t return_to = 18446744073709549517LLU;
48048+ uint64_t return_to = 18446744073709549515LLU;
4795648049 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4795748050 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4795848051 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47961,7 +48054,7 @@
4796148054 state.addr = 861504796319285248LLU; // typeu64___
4796248055 break;
4796348056 }
47964- case 18446744073709549517LLU: // 99999999dM'''''''''''''''
48057+ case 18446744073709549515LLU: // 99999999dK'''''''''''''''
4796548058 {
4796648059 {
4796748060 uint64_t arg = 0;
@@ -48055,7 +48148,7 @@
4805548148 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4805648149 }
4805748150 // ACCUMULATE ARGUMENTS - END
48058- uint64_t return_to = 18446744073709549516LLU;
48151+ uint64_t return_to = 18446744073709549514LLU;
4805948152 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4806048153 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4806148154 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48064,7 +48157,7 @@
4806448157 state.addr = 293363126232490310LLU; // PROCVARREF
4806548158 break;
4806648159 }
48067- case 18446744073709549516LLU: // 99999999dL'''''''''''''''
48160+ case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
4806848161 {
4806948162 // ACCUMULATE ARGUMENTS - BEGIN
4807048163 {
@@ -48076,7 +48169,7 @@
4807648169 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4807748170 }
4807848171 // ACCUMULATE ARGUMENTS - END
48079- uint64_t return_to = 18446744073709549515LLU;
48172+ uint64_t return_to = 18446744073709549513LLU;
4808048173 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4808148174 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4808248175 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48085,7 +48178,7 @@
4808548178 state.addr = 517555565474237359LLU; // assertlist
4808648179 break;
4808748180 }
48088- case 18446744073709549515LLU: // 99999999dK'''''''''''''''
48181+ case 18446744073709549513LLU: // 99999999dI'''''''''''''''
4808948182 {
4809048183 // variable u64 mutable0__ goes out of scope
4809148184 // emitted destructur for type u64
@@ -48113,7 +48206,7 @@
4811348206 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4811448207 }
4811548208 // ACCUMULATE ARGUMENTS - END
48116- uint64_t return_to = 18446744073709549514LLU;
48209+ uint64_t return_to = 18446744073709549512LLU;
4811748210 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4811848211 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4811948212 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48122,7 +48215,7 @@
4812248215 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4812348216 break;
4812448217 }
48125- case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
48218+ case 18446744073709549512LLU: // 99999999dH'''''''''''''''
4812648219 {
4812748220 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 18
4812848221 fprintf(stdout, "%s", ");");
@@ -48132,7 +48225,7 @@
4813248225 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4813348226 }
4813448227 // ACCUMULATE ARGUMENTS - END
48135- uint64_t return_to = 18446744073709549513LLU;
48228+ uint64_t return_to = 18446744073709549511LLU;
4813648229 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4813748230 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4813848231 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48141,7 +48234,7 @@
4814148234 state.addr = 839519665163075584LLU; // skip______
4814248235 break;
4814348236 }
48144- case 18446744073709549513LLU: // 99999999dI'''''''''''''''
48237+ case 18446744073709549511LLU: // 99999999dG'''''''''''''''
4814548238 {
4814648239 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4814748240 // variable resdest___ single____ goes out of scope
@@ -48152,7 +48245,7 @@
4815248245 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4815348246 }
4815448247 // ACCUMULATE ARGUMENTS - END
48155- uint64_t return_to = 18446744073709549512LLU;
48248+ uint64_t return_to = 18446744073709549510LLU;
4815648249 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4815748250 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4815848251 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48161,43 +48254,43 @@
4816148254 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4816248255 break;
4816348256 }
48164- case 18446744073709549512LLU: // 99999999dH'''''''''''''''
48257+ case 18446744073709549510LLU: // 99999999dF'''''''''''''''
4816548258 {
4816648259 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
48167- state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
48260+ state.addr = 18446744073709549522LLU; // 99999999dR'''''''''''''''
4816848261 break;
4816948262 }
48170- case 18446744073709549525LLU: // 99999999dU'''''''''''''''
48263+ case 18446744073709549523LLU: // 99999999dS'''''''''''''''
4817148264 {
48172- state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
48265+ state.addr = 18446744073709549522LLU; // 99999999dR'''''''''''''''
4817348266 break;
4817448267 }
48175- case 18446744073709549524LLU: // 99999999dT'''''''''''''''
48268+ case 18446744073709549522LLU: // 99999999dR'''''''''''''''
4817648269 {
48177- state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
48270+ state.addr = 18446744073709549537LLU; // 99999999df'''''''''''''''
4817848271 break;
4817948272 }
48180- case 18446744073709549539LLU: // 99999999dh'''''''''''''''
48273+ case 18446744073709549537LLU: // 99999999df'''''''''''''''
4818148274 {
48182- state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
48275+ state.addr = 18446744073709549555LLU; // 99999999dx'''''''''''''''
4818348276 break;
4818448277 }
48185- case 18446744073709549557LLU: // 99999999dz'''''''''''''''
48278+ case 18446744073709549555LLU: // 99999999dx'''''''''''''''
4818648279 {
48187- state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
48280+ state.addr = 18446744073709549573LLU; // 99999999eE'''''''''''''''
4818848281 break;
4818948282 }
48190- case 18446744073709549575LLU: // 99999999eG'''''''''''''''
48283+ case 18446744073709549573LLU: // 99999999eE'''''''''''''''
4819148284 {
48192- state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
48285+ state.addr = 18446744073709549589LLU; // 99999999eU'''''''''''''''
4819348286 break;
4819448287 }
48195- case 18446744073709549591LLU: // 99999999eW'''''''''''''''
48288+ case 18446744073709549589LLU: // 99999999eU'''''''''''''''
4819648289 {
48197- state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
48290+ state.addr = 18446744073709549605LLU; // 99999999ej'''''''''''''''
4819848291 break;
4819948292 }
48200- case 18446744073709549607LLU: // 99999999el'''''''''''''''
48293+ case 18446744073709549605LLU: // 99999999ej'''''''''''''''
4820148294 {
4820248295 // variable u64 sym_______ goes out of scope
4820348296 // emitted destructur for type u64
@@ -48256,11 +48349,11 @@
4825648349 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4825748350 }
4825848351 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48259- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549511LLU : 18446744073709549510LLU;
48352+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549509LLU : 18446744073709549508LLU;
4826048353 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4826148354 break;
4826248355 }
48263- case 18446744073709549511LLU: // 99999999dG'''''''''''''''
48356+ case 18446744073709549509LLU: // 99999999dE'''''''''''''''
4826448357 {
4826548358 {
4826648359 uint64_t arg = 0;
@@ -48287,7 +48380,7 @@
4828748380 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4828848381 }
4828948382 // ACCUMULATE ARGUMENTS - END
48290- uint64_t return_to = 18446744073709549508LLU;
48383+ uint64_t return_to = 18446744073709549506LLU;
4829148384 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4829248385 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4829348386 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48296,7 +48389,7 @@
4829648389 state.addr = 861504796319285248LLU; // typeu64___
4829748390 break;
4829848391 }
48299- case 18446744073709549508LLU: // 99999999dD'''''''''''''''
48392+ case 18446744073709549506LLU: // 99999999dB'''''''''''''''
4830048393 {
4830148394 {
4830248395 uint64_t arg = 0;
@@ -48321,7 +48414,7 @@
4832148414 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4832248415 }
4832348416 // ACCUMULATE ARGUMENTS - END
48324- uint64_t return_to = 18446744073709549506LLU;
48417+ uint64_t return_to = 18446744073709549504LLU;
4832548418 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4832648419 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4832748420 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48330,7 +48423,7 @@
4833048423 state.addr = 861504796319285248LLU; // typeu64___
4833148424 break;
4833248425 }
48333- case 18446744073709549506LLU: // 99999999dB'''''''''''''''
48426+ case 18446744073709549504LLU: // 99999999d_'''''''''''''''
4833448427 {
4833548428 {
4833648429 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -48350,7 +48443,7 @@
4835048443 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4835148444 }
4835248445 // ACCUMULATE ARGUMENTS - END
48353- uint64_t return_to = 18446744073709549507LLU;
48446+ uint64_t return_to = 18446744073709549505LLU;
4835448447 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4835548448 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4835648449 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48359,7 +48452,7 @@
4835948452 state.addr = 819859607768530944LLU; // resdest___
4836048453 break;
4836148454 }
48362- case 18446744073709549507LLU: // 99999999dC'''''''''''''''
48455+ case 18446744073709549505LLU: // 99999999dA'''''''''''''''
4836348456 {
4836448457 // ACCUMULATE ARGUMENTS - BEGIN
4836548458 {
@@ -48379,7 +48472,7 @@
4837948472 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4838048473 }
4838148474 // ACCUMULATE ARGUMENTS - END
48382- uint64_t return_to = 18446744073709549505LLU;
48475+ uint64_t return_to = 18446744073709549503LLU;
4838348476 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4838448477 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4838548478 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48388,7 +48481,7 @@
4838848481 state.addr = 819857494882385920LLU; // res_u64___
4838948482 break;
4839048483 }
48391- case 18446744073709549505LLU: // 99999999dA'''''''''''''''
48484+ case 18446744073709549503LLU: // 99999999c9'''''''''''''''
4839248485 {
4839348486 // ACCUMULATE ARGUMENTS - BEGIN
4839448487 {
@@ -48396,7 +48489,7 @@
4839648489 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4839748490 }
4839848491 // ACCUMULATE ARGUMENTS - END
48399- uint64_t return_to = 18446744073709549504LLU;
48492+ uint64_t return_to = 18446744073709549502LLU;
4840048493 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4840148494 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4840248495 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48405,7 +48498,7 @@
4840548498 state.addr = 839519665163075584LLU; // skip______
4840648499 break;
4840748500 }
48408- case 18446744073709549504LLU: // 99999999d_'''''''''''''''
48501+ case 18446744073709549502LLU: // 99999999c8'''''''''''''''
4840948502 {
4841048503 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4841148504 fprintf(stdout, "%s", "\n ");
@@ -48431,7 +48524,7 @@
4843148524 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4843248525 }
4843348526 // ACCUMULATE ARGUMENTS - END
48434- uint64_t return_to = 18446744073709549503LLU;
48527+ uint64_t return_to = 18446744073709549501LLU;
4843548528 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4843648529 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4843748530 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48440,7 +48533,7 @@
4844048533 state.addr = 587881357514113024LLU; // emitpar___
4844148534 break;
4844248535 }
48443- case 18446744073709549503LLU: // 99999999c9'''''''''''''''
48536+ case 18446744073709549501LLU: // 99999999c7'''''''''''''''
4844448537 {
4844548538 fprintf(stdout, "%s", " = ");
4844648539 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48449,7 +48542,7 @@
4844948542 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4845048543 }
4845148544 // ACCUMULATE ARGUMENTS - END
48452- uint64_t return_to = 18446744073709549502LLU;
48545+ uint64_t return_to = 18446744073709549500LLU;
4845348546 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4845448547 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4845548548 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48458,7 +48551,7 @@
4845848551 state.addr = 839519665163075584LLU; // skip______
4845948552 break;
4846048553 }
48461- case 18446744073709549502LLU: // 99999999c8'''''''''''''''
48554+ case 18446744073709549500LLU: // 99999999c6'''''''''''''''
4846248555 {
4846348556
4846448557 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -48480,7 +48573,7 @@
4848048573 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4848148574 }
4848248575 // ACCUMULATE ARGUMENTS - END
48483- uint64_t return_to = 18446744073709549501LLU;
48576+ uint64_t return_to = 18446744073709549499LLU;
4848448577 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4848548578 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4848648579 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48489,7 +48582,7 @@
4848948582 state.addr = 23446349213393492LLU; // ASSERTINIT
4849048583 break;
4849148584 }
48492- case 18446744073709549501LLU: // 99999999c7'''''''''''''''
48585+ case 18446744073709549499LLU: // 99999999c5'''''''''''''''
4849348586 {
4849448587 {
4849548588 uint64_t arg = 0;
@@ -48568,7 +48661,7 @@
4856848661 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4856948662 }
4857048663 // ACCUMULATE ARGUMENTS - END
48571- uint64_t return_to = 18446744073709549500LLU;
48664+ uint64_t return_to = 18446744073709549498LLU;
4857248665 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4857348666 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4857448667 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48577,7 +48670,7 @@
4857748670 state.addr = 293363126232490310LLU; // PROCVARREF
4857848671 break;
4857948672 }
48580- case 18446744073709549500LLU: // 99999999c6'''''''''''''''
48673+ case 18446744073709549498LLU: // 99999999c4'''''''''''''''
4858148674 {
4858248675 // variable u64 initialize goes out of scope
4858348676 // emitted destructur for type u64
@@ -48598,7 +48691,7 @@
4859848691 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4859948692 }
4860048693 // ACCUMULATE ARGUMENTS - END
48601- uint64_t return_to = 18446744073709549499LLU;
48694+ uint64_t return_to = 18446744073709549497LLU;
4860248695 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4860348696 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4860448697 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48607,7 +48700,7 @@
4860748700 state.addr = 517555565476695680LLU; // assertu64_
4860848701 break;
4860948702 }
48610- case 18446744073709549499LLU: // 99999999c5'''''''''''''''
48703+ case 18446744073709549497LLU: // 99999999c3'''''''''''''''
4861148704 {
4861248705 // ACCUMULATE ARGUMENTS - BEGIN
4861348706 {
@@ -48615,7 +48708,7 @@
4861548708 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4861648709 }
4861748710 // ACCUMULATE ARGUMENTS - END
48618- uint64_t return_to = 18446744073709549498LLU;
48711+ uint64_t return_to = 18446744073709549496LLU;
4861948712 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4862048713 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4862148714 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48624,7 +48717,7 @@
4862448717 state.addr = 839519665163075584LLU; // skip______
4862548718 break;
4862648719 }
48627- case 18446744073709549498LLU: // 99999999c4'''''''''''''''
48720+ case 18446744073709549496LLU: // 99999999c2'''''''''''''''
4862848721 {
4862948722 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4863048723 fprintf(stdout, "%s", " & ");
@@ -48634,7 +48727,7 @@
4863448727 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4863548728 }
4863648729 // ACCUMULATE ARGUMENTS - END
48637- uint64_t return_to = 18446744073709549497LLU;
48730+ uint64_t return_to = 18446744073709549495LLU;
4863848731 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4863948732 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4864048733 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48643,7 +48736,7 @@
4864348736 state.addr = 839519665163075584LLU; // skip______
4864448737 break;
4864548738 }
48646- case 18446744073709549497LLU: // 99999999c3'''''''''''''''
48739+ case 18446744073709549495LLU: // 99999999c1'''''''''''''''
4864748740 {
4864848741
4864948742 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -48665,7 +48758,7 @@
4866548758 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4866648759 }
4866748760 // ACCUMULATE ARGUMENTS - END
48668- uint64_t return_to = 18446744073709549496LLU;
48761+ uint64_t return_to = 18446744073709549494LLU;
4866948762 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4867048763 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4867148764 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48674,7 +48767,7 @@
4867448767 state.addr = 23446349213393492LLU; // ASSERTINIT
4867548768 break;
4867648769 }
48677- case 18446744073709549496LLU: // 99999999c2'''''''''''''''
48770+ case 18446744073709549494LLU: // 99999999c0'''''''''''''''
4867848771 {
4867948772 {
4868048773 uint64_t arg = 0;
@@ -48753,7 +48846,7 @@
4875348846 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4875448847 }
4875548848 // ACCUMULATE ARGUMENTS - END
48756- uint64_t return_to = 18446744073709549495LLU;
48849+ uint64_t return_to = 18446744073709549493LLU;
4875748850 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4875848851 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4875948852 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48762,7 +48855,7 @@
4876248855 state.addr = 293363126232490310LLU; // PROCVARREF
4876348856 break;
4876448857 }
48765- case 18446744073709549495LLU: // 99999999c1'''''''''''''''
48858+ case 18446744073709549493LLU: // 99999999cz'''''''''''''''
4876648859 {
4876748860 // variable u64 initialize goes out of scope
4876848861 // emitted destructur for type u64
@@ -48783,7 +48876,7 @@
4878348876 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4878448877 }
4878548878 // ACCUMULATE ARGUMENTS - END
48786- uint64_t return_to = 18446744073709549494LLU;
48879+ uint64_t return_to = 18446744073709549492LLU;
4878748880 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4878848881 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4878948882 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48792,7 +48885,7 @@
4879248885 state.addr = 517555565476695680LLU; // assertu64_
4879348886 break;
4879448887 }
48795- case 18446744073709549494LLU: // 99999999c0'''''''''''''''
48888+ case 18446744073709549492LLU: // 99999999cy'''''''''''''''
4879648889 {
4879748890 // ACCUMULATE ARGUMENTS - BEGIN
4879848891 {
@@ -48800,7 +48893,7 @@
4880048893 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4880148894 }
4880248895 // ACCUMULATE ARGUMENTS - END
48803- uint64_t return_to = 18446744073709549493LLU;
48896+ uint64_t return_to = 18446744073709549491LLU;
4880448897 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4880548898 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4880648899 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48809,7 +48902,7 @@
4880948902 state.addr = 839519665163075584LLU; // skip______
4881048903 break;
4881148904 }
48812- case 18446744073709549493LLU: // 99999999cz'''''''''''''''
48905+ case 18446744073709549491LLU: // 99999999cx'''''''''''''''
4881348906 {
4881448907 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4881548908 fprintf(stdout, "%s", ";");
@@ -48821,7 +48914,7 @@
4882148914 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4882248915 }
4882348916 // ACCUMULATE ARGUMENTS - END
48824- uint64_t return_to = 18446744073709549492LLU;
48917+ uint64_t return_to = 18446744073709549490LLU;
4882548918 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4882648919 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4882748920 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48830,7 +48923,7 @@
4883048923 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4883148924 break;
4883248925 }
48833- case 18446744073709549492LLU: // 99999999cy'''''''''''''''
48926+ case 18446744073709549490LLU: // 99999999cw'''''''''''''''
4883448927 {
4883548928 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4883648929 // variable type______ type______ goes out of scope
@@ -48841,7 +48934,7 @@
4884148934 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4884248935 }
4884348936 // ACCUMULATE ARGUMENTS - END
48844- uint64_t return_to = 18446744073709549491LLU;
48937+ uint64_t return_to = 18446744073709549489LLU;
4884548938 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4884648939 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4884748940 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48850,7 +48943,7 @@
4885048943 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4885148944 break;
4885248945 }
48853- case 18446744073709549491LLU: // 99999999cx'''''''''''''''
48946+ case 18446744073709549489LLU: // 99999999cv'''''''''''''''
4885448947 {
4885548948 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4885648949 // variable u64 mutable___ goes out of scope
@@ -48862,10 +48955,10 @@
4886248955 // variable u64 id________ goes out of scope
4886348956 // emitted destructur for type u64
4886448957 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
48865- state.addr = 18446744073709549509LLU; // 99999999dE'''''''''''''''
48958+ state.addr = 18446744073709549507LLU; // 99999999dC'''''''''''''''
4886648959 break;
4886748960 }
48868- case 18446744073709549510LLU: // 99999999dF'''''''''''''''
48961+ case 18446744073709549508LLU: // 99999999dD'''''''''''''''
4886948962 {
4887048963
4887148964 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 532757409974714368;
@@ -48876,11 +48969,11 @@
4887648969 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4887748970 }
4887848971 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48879- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549490LLU : 18446744073709549489LLU;
48972+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549488LLU : 18446744073709549487LLU;
4888048973 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4888148974 break;
4888248975 }
48883- case 18446744073709549490LLU: // 99999999cw'''''''''''''''
48976+ case 18446744073709549488LLU: // 99999999cu'''''''''''''''
4888448977 {
4888548978 {
4888648979 uint64_t arg = 0;
@@ -48907,7 +49000,7 @@
4890749000 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4890849001 }
4890949002 // ACCUMULATE ARGUMENTS - END
48910- uint64_t return_to = 18446744073709549487LLU;
49003+ uint64_t return_to = 18446744073709549485LLU;
4891149004 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4891249005 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4891349006 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48916,7 +49009,7 @@
4891649009 state.addr = 861504796319285248LLU; // typeu64___
4891749010 break;
4891849011 }
48919- case 18446744073709549487LLU: // 99999999ct'''''''''''''''
49012+ case 18446744073709549485LLU: // 99999999cr'''''''''''''''
4892049013 {
4892149014 {
4892249015 uint64_t arg = 0;
@@ -48941,7 +49034,7 @@
4894149034 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4894249035 }
4894349036 // ACCUMULATE ARGUMENTS - END
48944- uint64_t return_to = 18446744073709549485LLU;
49037+ uint64_t return_to = 18446744073709549483LLU;
4894549038 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4894649039 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4894749040 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48950,7 +49043,7 @@
4895049043 state.addr = 861504796319285248LLU; // typeu64___
4895149044 break;
4895249045 }
48953- case 18446744073709549485LLU: // 99999999cr'''''''''''''''
49046+ case 18446744073709549483LLU: // 99999999cp'''''''''''''''
4895449047 {
4895549048 {
4895649049 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -48970,7 +49063,7 @@
4897049063 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4897149064 }
4897249065 // ACCUMULATE ARGUMENTS - END
48973- uint64_t return_to = 18446744073709549486LLU;
49066+ uint64_t return_to = 18446744073709549484LLU;
4897449067 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4897549068 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4897649069 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48979,7 +49072,7 @@
4897949072 state.addr = 819859607768530944LLU; // resdest___
4898049073 break;
4898149074 }
48982- case 18446744073709549486LLU: // 99999999cs'''''''''''''''
49075+ case 18446744073709549484LLU: // 99999999cq'''''''''''''''
4898349076 {
4898449077 // ACCUMULATE ARGUMENTS - BEGIN
4898549078 {
@@ -48999,7 +49092,7 @@
4899949092 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4900049093 }
4900149094 // ACCUMULATE ARGUMENTS - END
49002- uint64_t return_to = 18446744073709549484LLU;
49095+ uint64_t return_to = 18446744073709549482LLU;
4900349096 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4900449097 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4900549098 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49008,7 +49101,7 @@
4900849101 state.addr = 819857494882385920LLU; // res_u64___
4900949102 break;
4901049103 }
49011- case 18446744073709549484LLU: // 99999999cq'''''''''''''''
49104+ case 18446744073709549482LLU: // 99999999co'''''''''''''''
4901249105 {
4901349106 // ACCUMULATE ARGUMENTS - BEGIN
4901449107 {
@@ -49016,7 +49109,7 @@
4901649109 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4901749110 }
4901849111 // ACCUMULATE ARGUMENTS - END
49019- uint64_t return_to = 18446744073709549483LLU;
49112+ uint64_t return_to = 18446744073709549481LLU;
4902049113 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4902149114 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4902249115 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49025,7 +49118,7 @@
4902549118 state.addr = 839519665163075584LLU; // skip______
4902649119 break;
4902749120 }
49028- case 18446744073709549483LLU: // 99999999cp'''''''''''''''
49121+ case 18446744073709549481LLU: // 99999999cn'''''''''''''''
4902949122 {
4903049123 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4903149124 fprintf(stdout, "%s", "\n ");
@@ -49051,7 +49144,7 @@
4905149144 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4905249145 }
4905349146 // ACCUMULATE ARGUMENTS - END
49054- uint64_t return_to = 18446744073709549482LLU;
49147+ uint64_t return_to = 18446744073709549480LLU;
4905549148 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4905649149 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4905749150 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49060,7 +49153,7 @@
4906049153 state.addr = 587881357514113024LLU; // emitpar___
4906149154 break;
4906249155 }
49063- case 18446744073709549482LLU: // 99999999co'''''''''''''''
49156+ case 18446744073709549480LLU: // 99999999cm'''''''''''''''
4906449157 {
4906549158 fprintf(stdout, "%s", " = ");
4906649159 // ACCUMULATE ARGUMENTS - BEGIN
@@ -49069,7 +49162,7 @@
4906949162 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4907049163 }
4907149164 // ACCUMULATE ARGUMENTS - END
49072- uint64_t return_to = 18446744073709549481LLU;
49165+ uint64_t return_to = 18446744073709549479LLU;
4907349166 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4907449167 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4907549168 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49078,7 +49171,7 @@
4907849171 state.addr = 839519665163075584LLU; // skip______
4907949172 break;
4908049173 }
49081- case 18446744073709549481LLU: // 99999999cn'''''''''''''''
49174+ case 18446744073709549479LLU: // 99999999cl'''''''''''''''
4908249175 {
4908349176
4908449177 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49100,7 +49193,7 @@
4910049193 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4910149194 }
4910249195 // ACCUMULATE ARGUMENTS - END
49103- uint64_t return_to = 18446744073709549480LLU;
49196+ uint64_t return_to = 18446744073709549478LLU;
4910449197 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4910549198 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4910649199 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49109,7 +49202,7 @@
4910949202 state.addr = 23446349213393492LLU; // ASSERTINIT
4911049203 break;
4911149204 }
49112- case 18446744073709549480LLU: // 99999999cm'''''''''''''''
49205+ case 18446744073709549478LLU: // 99999999ck'''''''''''''''
4911349206 {
4911449207 {
4911549208 uint64_t arg = 0;
@@ -49188,7 +49281,7 @@
4918849281 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4918949282 }
4919049283 // ACCUMULATE ARGUMENTS - END
49191- uint64_t return_to = 18446744073709549479LLU;
49284+ uint64_t return_to = 18446744073709549477LLU;
4919249285 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4919349286 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4919449287 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49197,7 +49290,7 @@
4919749290 state.addr = 293363126232490310LLU; // PROCVARREF
4919849291 break;
4919949292 }
49200- case 18446744073709549479LLU: // 99999999cl'''''''''''''''
49293+ case 18446744073709549477LLU: // 99999999cj'''''''''''''''
4920149294 {
4920249295 // variable u64 initialize goes out of scope
4920349296 // emitted destructur for type u64
@@ -49218,7 +49311,7 @@
4921849311 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4921949312 }
4922049313 // ACCUMULATE ARGUMENTS - END
49221- uint64_t return_to = 18446744073709549478LLU;
49314+ uint64_t return_to = 18446744073709549476LLU;
4922249315 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4922349316 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4922449317 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49227,7 +49320,7 @@
4922749320 state.addr = 517555565476695680LLU; // assertu64_
4922849321 break;
4922949322 }
49230- case 18446744073709549478LLU: // 99999999ck'''''''''''''''
49323+ case 18446744073709549476LLU: // 99999999ci'''''''''''''''
4923149324 {
4923249325 // ACCUMULATE ARGUMENTS - BEGIN
4923349326 {
@@ -49235,7 +49328,7 @@
4923549328 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4923649329 }
4923749330 // ACCUMULATE ARGUMENTS - END
49238- uint64_t return_to = 18446744073709549477LLU;
49331+ uint64_t return_to = 18446744073709549475LLU;
4923949332 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4924049333 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4924149334 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49244,7 +49337,7 @@
4924449337 state.addr = 839519665163075584LLU; // skip______
4924549338 break;
4924649339 }
49247- case 18446744073709549477LLU: // 99999999cj'''''''''''''''
49340+ case 18446744073709549475LLU: // 99999999ch'''''''''''''''
4924849341 {
4924949342 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4925049343 fprintf(stdout, "%s", " | ");
@@ -49254,7 +49347,7 @@
4925449347 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4925549348 }
4925649349 // ACCUMULATE ARGUMENTS - END
49257- uint64_t return_to = 18446744073709549476LLU;
49350+ uint64_t return_to = 18446744073709549474LLU;
4925849351 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4925949352 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4926049353 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49263,7 +49356,7 @@
4926349356 state.addr = 839519665163075584LLU; // skip______
4926449357 break;
4926549358 }
49266- case 18446744073709549476LLU: // 99999999ci'''''''''''''''
49359+ case 18446744073709549474LLU: // 99999999cg'''''''''''''''
4926749360 {
4926849361
4926949362 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49285,7 +49378,7 @@
4928549378 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4928649379 }
4928749380 // ACCUMULATE ARGUMENTS - END
49288- uint64_t return_to = 18446744073709549475LLU;
49381+ uint64_t return_to = 18446744073709549473LLU;
4928949382 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4929049383 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4929149384 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49294,7 +49387,7 @@
4929449387 state.addr = 23446349213393492LLU; // ASSERTINIT
4929549388 break;
4929649389 }
49297- case 18446744073709549475LLU: // 99999999ch'''''''''''''''
49390+ case 18446744073709549473LLU: // 99999999cf'''''''''''''''
4929849391 {
4929949392 {
4930049393 uint64_t arg = 0;
@@ -49373,7 +49466,7 @@
4937349466 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4937449467 }
4937549468 // ACCUMULATE ARGUMENTS - END
49376- uint64_t return_to = 18446744073709549474LLU;
49469+ uint64_t return_to = 18446744073709549472LLU;
4937749470 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4937849471 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4937949472 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49382,7 +49475,7 @@
4938249475 state.addr = 293363126232490310LLU; // PROCVARREF
4938349476 break;
4938449477 }
49385- case 18446744073709549474LLU: // 99999999cg'''''''''''''''
49478+ case 18446744073709549472LLU: // 99999999ce'''''''''''''''
4938649479 {
4938749480 // variable u64 initialize goes out of scope
4938849481 // emitted destructur for type u64
@@ -49403,7 +49496,7 @@
4940349496 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4940449497 }
4940549498 // ACCUMULATE ARGUMENTS - END
49406- uint64_t return_to = 18446744073709549473LLU;
49499+ uint64_t return_to = 18446744073709549471LLU;
4940749500 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4940849501 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4940949502 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49412,7 +49505,7 @@
4941249505 state.addr = 517555565476695680LLU; // assertu64_
4941349506 break;
4941449507 }
49415- case 18446744073709549473LLU: // 99999999cf'''''''''''''''
49508+ case 18446744073709549471LLU: // 99999999cd'''''''''''''''
4941649509 {
4941749510 // ACCUMULATE ARGUMENTS - BEGIN
4941849511 {
@@ -49420,7 +49513,7 @@
4942049513 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4942149514 }
4942249515 // ACCUMULATE ARGUMENTS - END
49423- uint64_t return_to = 18446744073709549472LLU;
49516+ uint64_t return_to = 18446744073709549470LLU;
4942449517 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4942549518 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4942649519 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49429,7 +49522,7 @@
4942949522 state.addr = 839519665163075584LLU; // skip______
4943049523 break;
4943149524 }
49432- case 18446744073709549472LLU: // 99999999ce'''''''''''''''
49525+ case 18446744073709549470LLU: // 99999999cc'''''''''''''''
4943349526 {
4943449527 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4943549528 fprintf(stdout, "%s", ";");
@@ -49441,7 +49534,7 @@
4944149534 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4944249535 }
4944349536 // ACCUMULATE ARGUMENTS - END
49444- uint64_t return_to = 18446744073709549471LLU;
49537+ uint64_t return_to = 18446744073709549469LLU;
4944549538 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4944649539 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4944749540 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49450,7 +49543,7 @@
4945049543 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4945149544 break;
4945249545 }
49453- case 18446744073709549471LLU: // 99999999cd'''''''''''''''
49546+ case 18446744073709549469LLU: // 99999999cb'''''''''''''''
4945449547 {
4945549548 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4945649549 // variable type______ type______ goes out of scope
@@ -49461,7 +49554,7 @@
4946149554 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4946249555 }
4946349556 // ACCUMULATE ARGUMENTS - END
49464- uint64_t return_to = 18446744073709549470LLU;
49557+ uint64_t return_to = 18446744073709549468LLU;
4946549558 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4946649559 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4946749560 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49470,7 +49563,7 @@
4947049563 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4947149564 break;
4947249565 }
49473- case 18446744073709549470LLU: // 99999999cc'''''''''''''''
49566+ case 18446744073709549468LLU: // 99999999ca'''''''''''''''
4947449567 {
4947549568 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4947649569 // variable u64 mutable___ goes out of scope
@@ -49482,10 +49575,10 @@
4948249575 // variable u64 id________ goes out of scope
4948349576 // emitted destructur for type u64
4948449577 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
49485- state.addr = 18446744073709549488LLU; // 99999999cu'''''''''''''''
49578+ state.addr = 18446744073709549486LLU; // 99999999cs'''''''''''''''
4948649579 break;
4948749580 }
49488- case 18446744073709549489LLU: // 99999999cv'''''''''''''''
49581+ case 18446744073709549487LLU: // 99999999ct'''''''''''''''
4948949582 {
4949049583
4949149584 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 516079971752476672;
@@ -49496,11 +49589,11 @@
4949649589 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4949749590 }
4949849591 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
49499- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549469LLU : 18446744073709549468LLU;
49592+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549467LLU : 18446744073709549466LLU;
4950049593 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4950149594 break;
4950249595 }
49503- case 18446744073709549469LLU: // 99999999cb'''''''''''''''
49596+ case 18446744073709549467LLU: // 99999999c$'''''''''''''''
4950449597 {
4950549598 {
4950649599 uint64_t arg = 0;
@@ -49527,7 +49620,7 @@
4952749620 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4952849621 }
4952949622 // ACCUMULATE ARGUMENTS - END
49530- uint64_t return_to = 18446744073709549466LLU;
49623+ uint64_t return_to = 18446744073709549464LLU;
4953149624 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4953249625 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4953349626 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49536,7 +49629,7 @@
4953649629 state.addr = 861504796319285248LLU; // typeu64___
4953749630 break;
4953849631 }
49539- case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
49632+ case 18446744073709549464LLU: // 99999999cX'''''''''''''''
4954049633 {
4954149634 {
4954249635 uint64_t arg = 0;
@@ -49561,7 +49654,7 @@
4956149654 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4956249655 }
4956349656 // ACCUMULATE ARGUMENTS - END
49564- uint64_t return_to = 18446744073709549464LLU;
49657+ uint64_t return_to = 18446744073709549462LLU;
4956549658 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4956649659 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4956749660 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49570,7 +49663,7 @@
4957049663 state.addr = 861504796319285248LLU; // typeu64___
4957149664 break;
4957249665 }
49573- case 18446744073709549464LLU: // 99999999cX'''''''''''''''
49666+ case 18446744073709549462LLU: // 99999999cV'''''''''''''''
4957449667 {
4957549668 {
4957649669 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -49590,7 +49683,7 @@
4959049683 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4959149684 }
4959249685 // ACCUMULATE ARGUMENTS - END
49593- uint64_t return_to = 18446744073709549465LLU;
49686+ uint64_t return_to = 18446744073709549463LLU;
4959449687 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4959549688 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4959649689 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49599,7 +49692,7 @@
4959949692 state.addr = 819859607768530944LLU; // resdest___
4960049693 break;
4960149694 }
49602- case 18446744073709549465LLU: // 99999999cY'''''''''''''''
49695+ case 18446744073709549463LLU: // 99999999cW'''''''''''''''
4960349696 {
4960449697 // ACCUMULATE ARGUMENTS - BEGIN
4960549698 {
@@ -49619,7 +49712,7 @@
4961949712 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4962049713 }
4962149714 // ACCUMULATE ARGUMENTS - END
49622- uint64_t return_to = 18446744073709549463LLU;
49715+ uint64_t return_to = 18446744073709549461LLU;
4962349716 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4962449717 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4962549718 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49628,7 +49721,7 @@
4962849721 state.addr = 819857494882385920LLU; // res_u64___
4962949722 break;
4963049723 }
49631- case 18446744073709549463LLU: // 99999999cW'''''''''''''''
49724+ case 18446744073709549461LLU: // 99999999cU'''''''''''''''
4963249725 {
4963349726 // ACCUMULATE ARGUMENTS - BEGIN
4963449727 {
@@ -49636,7 +49729,7 @@
4963649729 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4963749730 }
4963849731 // ACCUMULATE ARGUMENTS - END
49639- uint64_t return_to = 18446744073709549462LLU;
49732+ uint64_t return_to = 18446744073709549460LLU;
4964049733 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4964149734 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4964249735 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49645,7 +49738,7 @@
4964549738 state.addr = 839519665163075584LLU; // skip______
4964649739 break;
4964749740 }
49648- case 18446744073709549462LLU: // 99999999cV'''''''''''''''
49741+ case 18446744073709549460LLU: // 99999999cT'''''''''''''''
4964949742 {
4965049743 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4965149744 fprintf(stdout, "%s", "\n ");
@@ -49671,7 +49764,7 @@
4967149764 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4967249765 }
4967349766 // ACCUMULATE ARGUMENTS - END
49674- uint64_t return_to = 18446744073709549461LLU;
49767+ uint64_t return_to = 18446744073709549459LLU;
4967549768 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4967649769 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4967749770 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49680,7 +49773,7 @@
4968049773 state.addr = 587881357514113024LLU; // emitpar___
4968149774 break;
4968249775 }
49683- case 18446744073709549461LLU: // 99999999cU'''''''''''''''
49776+ case 18446744073709549459LLU: // 99999999cS'''''''''''''''
4968449777 {
4968549778 fprintf(stdout, "%s", " = ");
4968649779 // ACCUMULATE ARGUMENTS - BEGIN
@@ -49689,7 +49782,7 @@
4968949782 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4969049783 }
4969149784 // ACCUMULATE ARGUMENTS - END
49692- uint64_t return_to = 18446744073709549460LLU;
49785+ uint64_t return_to = 18446744073709549458LLU;
4969349786 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4969449787 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4969549788 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49698,7 +49791,7 @@
4969849791 state.addr = 839519665163075584LLU; // skip______
4969949792 break;
4970049793 }
49701- case 18446744073709549460LLU: // 99999999cT'''''''''''''''
49794+ case 18446744073709549458LLU: // 99999999cR'''''''''''''''
4970249795 {
4970349796
4970449797 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49720,7 +49813,7 @@
4972049813 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4972149814 }
4972249815 // ACCUMULATE ARGUMENTS - END
49723- uint64_t return_to = 18446744073709549459LLU;
49816+ uint64_t return_to = 18446744073709549457LLU;
4972449817 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4972549818 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4972649819 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49729,7 +49822,7 @@
4972949822 state.addr = 23446349213393492LLU; // ASSERTINIT
4973049823 break;
4973149824 }
49732- case 18446744073709549459LLU: // 99999999cS'''''''''''''''
49825+ case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
4973349826 {
4973449827 {
4973549828 uint64_t arg = 0;
@@ -49808,7 +49901,7 @@
4980849901 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4980949902 }
4981049903 // ACCUMULATE ARGUMENTS - END
49811- uint64_t return_to = 18446744073709549458LLU;
49904+ uint64_t return_to = 18446744073709549456LLU;
4981249905 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4981349906 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4981449907 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49817,7 +49910,7 @@
4981749910 state.addr = 293363126232490310LLU; // PROCVARREF
4981849911 break;
4981949912 }
49820- case 18446744073709549458LLU: // 99999999cR'''''''''''''''
49913+ case 18446744073709549456LLU: // 99999999cP'''''''''''''''
4982149914 {
4982249915 // variable u64 initialize goes out of scope
4982349916 // emitted destructur for type u64
@@ -49838,7 +49931,7 @@
4983849931 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4983949932 }
4984049933 // ACCUMULATE ARGUMENTS - END
49841- uint64_t return_to = 18446744073709549457LLU;
49934+ uint64_t return_to = 18446744073709549455LLU;
4984249935 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4984349936 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4984449937 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49847,7 +49940,7 @@
4984749940 state.addr = 517555565476695680LLU; // assertu64_
4984849941 break;
4984949942 }
49850- case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
49943+ case 18446744073709549455LLU: // 99999999cO'''''''''''''''
4985149944 {
4985249945 // ACCUMULATE ARGUMENTS - BEGIN
4985349946 {
@@ -49855,7 +49948,7 @@
4985549948 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4985649949 }
4985749950 // ACCUMULATE ARGUMENTS - END
49858- uint64_t return_to = 18446744073709549456LLU;
49951+ uint64_t return_to = 18446744073709549454LLU;
4985949952 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4986049953 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4986149954 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49864,7 +49957,7 @@
4986449957 state.addr = 839519665163075584LLU; // skip______
4986549958 break;
4986649959 }
49867- case 18446744073709549456LLU: // 99999999cP'''''''''''''''
49960+ case 18446744073709549454LLU: // 99999999cN'''''''''''''''
4986849961 {
4986949962 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4987049963 fprintf(stdout, "%s", " && ");
@@ -49874,7 +49967,7 @@
4987449967 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4987549968 }
4987649969 // ACCUMULATE ARGUMENTS - END
49877- uint64_t return_to = 18446744073709549455LLU;
49970+ uint64_t return_to = 18446744073709549453LLU;
4987849971 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4987949972 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4988049973 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49883,7 +49976,7 @@
4988349976 state.addr = 839519665163075584LLU; // skip______
4988449977 break;
4988549978 }
49886- case 18446744073709549455LLU: // 99999999cO'''''''''''''''
49979+ case 18446744073709549453LLU: // 99999999cM'''''''''''''''
4988749980 {
4988849981
4988949982 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49905,7 +49998,7 @@
4990549998 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4990649999 }
4990750000 // ACCUMULATE ARGUMENTS - END
49908- uint64_t return_to = 18446744073709549454LLU;
50001+ uint64_t return_to = 18446744073709549452LLU;
4990950002 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4991050003 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4991150004 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49914,7 +50007,7 @@
4991450007 state.addr = 23446349213393492LLU; // ASSERTINIT
4991550008 break;
4991650009 }
49917- case 18446744073709549454LLU: // 99999999cN'''''''''''''''
50010+ case 18446744073709549452LLU: // 99999999cL'''''''''''''''
4991850011 {
4991950012 {
4992050013 uint64_t arg = 0;
@@ -49993,7 +50086,7 @@
4999350086 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4999450087 }
4999550088 // ACCUMULATE ARGUMENTS - END
49996- uint64_t return_to = 18446744073709549453LLU;
50089+ uint64_t return_to = 18446744073709549451LLU;
4999750090 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4999850091 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4999950092 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50002,7 +50095,7 @@
5000250095 state.addr = 293363126232490310LLU; // PROCVARREF
5000350096 break;
5000450097 }
50005- case 18446744073709549453LLU: // 99999999cM'''''''''''''''
50098+ case 18446744073709549451LLU: // 99999999cK'''''''''''''''
5000650099 {
5000750100 // variable u64 initialize goes out of scope
5000850101 // emitted destructur for type u64
@@ -50023,7 +50116,7 @@
5002350116 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5002450117 }
5002550118 // ACCUMULATE ARGUMENTS - END
50026- uint64_t return_to = 18446744073709549452LLU;
50119+ uint64_t return_to = 18446744073709549450LLU;
5002750120 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5002850121 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5002950122 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50032,7 +50125,7 @@
5003250125 state.addr = 517555565476695680LLU; // assertu64_
5003350126 break;
5003450127 }
50035- case 18446744073709549452LLU: // 99999999cL'''''''''''''''
50128+ case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
5003650129 {
5003750130 // ACCUMULATE ARGUMENTS - BEGIN
5003850131 {
@@ -50040,7 +50133,7 @@
5004050133 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5004150134 }
5004250135 // ACCUMULATE ARGUMENTS - END
50043- uint64_t return_to = 18446744073709549451LLU;
50136+ uint64_t return_to = 18446744073709549449LLU;
5004450137 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5004550138 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5004650139 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50049,7 +50142,7 @@
5004950142 state.addr = 839519665163075584LLU; // skip______
5005050143 break;
5005150144 }
50052- case 18446744073709549451LLU: // 99999999cK'''''''''''''''
50145+ case 18446744073709549449LLU: // 99999999cI'''''''''''''''
5005350146 {
5005450147 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5005550148 fprintf(stdout, "%s", ";");
@@ -50061,7 +50154,7 @@
5006150154 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5006250155 }
5006350156 // ACCUMULATE ARGUMENTS - END
50064- uint64_t return_to = 18446744073709549450LLU;
50157+ uint64_t return_to = 18446744073709549448LLU;
5006550158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5006650159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5006750160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50070,7 +50163,7 @@
5007050163 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5007150164 break;
5007250165 }
50073- case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
50166+ case 18446744073709549448LLU: // 99999999cH'''''''''''''''
5007450167 {
5007550168 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5007650169 // variable type______ type______ goes out of scope
@@ -50081,7 +50174,7 @@
5008150174 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5008250175 }
5008350176 // ACCUMULATE ARGUMENTS - END
50084- uint64_t return_to = 18446744073709549449LLU;
50177+ uint64_t return_to = 18446744073709549447LLU;
5008550178 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5008650179 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5008750180 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50090,7 +50183,7 @@
5009050183 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5009150184 break;
5009250185 }
50093- case 18446744073709549449LLU: // 99999999cI'''''''''''''''
50186+ case 18446744073709549447LLU: // 99999999cG'''''''''''''''
5009450187 {
5009550188 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5009650189 // variable u64 mutable___ goes out of scope
@@ -50102,10 +50195,10 @@
5010250195 // variable u64 id________ goes out of scope
5010350196 // emitted destructur for type u64
5010450197 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
50105- state.addr = 18446744073709549467LLU; // 99999999c$'''''''''''''''
50198+ state.addr = 18446744073709549465LLU; // 99999999cY'''''''''''''''
5010650199 break;
5010750200 }
50108- case 18446744073709549468LLU: // 99999999ca'''''''''''''''
50201+ case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
5010950202 {
5011050203
5011150204 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 769271111350222848;
@@ -50116,11 +50209,11 @@
5011650209 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5011750210 }
5011850211 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50119- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549448LLU : 18446744073709549447LLU;
50212+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549446LLU : 18446744073709549445LLU;
5012050213 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5012150214 break;
5012250215 }
50123- case 18446744073709549448LLU: // 99999999cH'''''''''''''''
50216+ case 18446744073709549446LLU: // 99999999cF'''''''''''''''
5012450217 {
5012550218 {
5012650219 uint64_t arg = 0;
@@ -50147,7 +50240,7 @@
5014750240 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5014850241 }
5014950242 // ACCUMULATE ARGUMENTS - END
50150- uint64_t return_to = 18446744073709549445LLU;
50243+ uint64_t return_to = 18446744073709549443LLU;
5015150244 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5015250245 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5015350246 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50156,7 +50249,7 @@
5015650249 state.addr = 861504796319285248LLU; // typeu64___
5015750250 break;
5015850251 }
50159- case 18446744073709549445LLU: // 99999999cE'''''''''''''''
50252+ case 18446744073709549443LLU: // 99999999cC'''''''''''''''
5016050253 {
5016150254 {
5016250255 uint64_t arg = 0;
@@ -50181,7 +50274,7 @@
5018150274 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5018250275 }
5018350276 // ACCUMULATE ARGUMENTS - END
50184- uint64_t return_to = 18446744073709549443LLU;
50277+ uint64_t return_to = 18446744073709549441LLU;
5018550278 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5018650279 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5018750280 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50190,7 +50283,7 @@
5019050283 state.addr = 861504796319285248LLU; // typeu64___
5019150284 break;
5019250285 }
50193- case 18446744073709549443LLU: // 99999999cC'''''''''''''''
50286+ case 18446744073709549441LLU: // 99999999cA'''''''''''''''
5019450287 {
5019550288 {
5019650289 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -50210,7 +50303,7 @@
5021050303 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5021150304 }
5021250305 // ACCUMULATE ARGUMENTS - END
50213- uint64_t return_to = 18446744073709549444LLU;
50306+ uint64_t return_to = 18446744073709549442LLU;
5021450307 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5021550308 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5021650309 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50219,7 +50312,7 @@
5021950312 state.addr = 819859607768530944LLU; // resdest___
5022050313 break;
5022150314 }
50222- case 18446744073709549444LLU: // 99999999cD'''''''''''''''
50315+ case 18446744073709549442LLU: // 99999999cB'''''''''''''''
5022350316 {
5022450317 // ACCUMULATE ARGUMENTS - BEGIN
5022550318 {
@@ -50239,7 +50332,7 @@
5023950332 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5024050333 }
5024150334 // ACCUMULATE ARGUMENTS - END
50242- uint64_t return_to = 18446744073709549442LLU;
50335+ uint64_t return_to = 18446744073709549440LLU;
5024350336 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5024450337 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5024550338 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50248,7 +50341,7 @@
5024850341 state.addr = 819857494882385920LLU; // res_u64___
5024950342 break;
5025050343 }
50251- case 18446744073709549442LLU: // 99999999cB'''''''''''''''
50344+ case 18446744073709549440LLU: // 99999999c_'''''''''''''''
5025250345 {
5025350346 // ACCUMULATE ARGUMENTS - BEGIN
5025450347 {
@@ -50256,7 +50349,7 @@
5025650349 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5025750350 }
5025850351 // ACCUMULATE ARGUMENTS - END
50259- uint64_t return_to = 18446744073709549441LLU;
50352+ uint64_t return_to = 18446744073709549439LLU;
5026050353 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5026150354 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5026250355 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50265,7 +50358,7 @@
5026550358 state.addr = 839519665163075584LLU; // skip______
5026650359 break;
5026750360 }
50268- case 18446744073709549441LLU: // 99999999cA'''''''''''''''
50361+ case 18446744073709549439LLU: // 99999999b9'''''''''''''''
5026950362 {
5027050363 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5027150364 fprintf(stdout, "%s", "\n ");
@@ -50291,7 +50384,7 @@
5029150384 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5029250385 }
5029350386 // ACCUMULATE ARGUMENTS - END
50294- uint64_t return_to = 18446744073709549440LLU;
50387+ uint64_t return_to = 18446744073709549438LLU;
5029550388 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5029650389 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5029750390 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50300,7 +50393,7 @@
5030050393 state.addr = 587881357514113024LLU; // emitpar___
5030150394 break;
5030250395 }
50303- case 18446744073709549440LLU: // 99999999c_'''''''''''''''
50396+ case 18446744073709549438LLU: // 99999999b8'''''''''''''''
5030450397 {
5030550398 fprintf(stdout, "%s", " = ");
5030650399 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50309,7 +50402,7 @@
5030950402 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5031050403 }
5031150404 // ACCUMULATE ARGUMENTS - END
50312- uint64_t return_to = 18446744073709549439LLU;
50405+ uint64_t return_to = 18446744073709549437LLU;
5031350406 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5031450407 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5031550408 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50318,7 +50411,7 @@
5031850411 state.addr = 839519665163075584LLU; // skip______
5031950412 break;
5032050413 }
50321- case 18446744073709549439LLU: // 99999999b9'''''''''''''''
50414+ case 18446744073709549437LLU: // 99999999b7'''''''''''''''
5032250415 {
5032350416
5032450417 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50340,7 +50433,7 @@
5034050433 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5034150434 }
5034250435 // ACCUMULATE ARGUMENTS - END
50343- uint64_t return_to = 18446744073709549438LLU;
50436+ uint64_t return_to = 18446744073709549436LLU;
5034450437 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5034550438 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5034650439 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50349,7 +50442,7 @@
5034950442 state.addr = 23446349213393492LLU; // ASSERTINIT
5035050443 break;
5035150444 }
50352- case 18446744073709549438LLU: // 99999999b8'''''''''''''''
50445+ case 18446744073709549436LLU: // 99999999b6'''''''''''''''
5035350446 {
5035450447 {
5035550448 uint64_t arg = 0;
@@ -50428,7 +50521,7 @@
5042850521 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5042950522 }
5043050523 // ACCUMULATE ARGUMENTS - END
50431- uint64_t return_to = 18446744073709549437LLU;
50524+ uint64_t return_to = 18446744073709549435LLU;
5043250525 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5043350526 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5043450527 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50437,7 +50530,7 @@
5043750530 state.addr = 293363126232490310LLU; // PROCVARREF
5043850531 break;
5043950532 }
50440- case 18446744073709549437LLU: // 99999999b7'''''''''''''''
50533+ case 18446744073709549435LLU: // 99999999b5'''''''''''''''
5044150534 {
5044250535 // variable u64 initialize goes out of scope
5044350536 // emitted destructur for type u64
@@ -50458,7 +50551,7 @@
5045850551 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5045950552 }
5046050553 // ACCUMULATE ARGUMENTS - END
50461- uint64_t return_to = 18446744073709549436LLU;
50554+ uint64_t return_to = 18446744073709549434LLU;
5046250555 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5046350556 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5046450557 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50467,7 +50560,7 @@
5046750560 state.addr = 517555565476695680LLU; // assertu64_
5046850561 break;
5046950562 }
50470- case 18446744073709549436LLU: // 99999999b6'''''''''''''''
50563+ case 18446744073709549434LLU: // 99999999b4'''''''''''''''
5047150564 {
5047250565 // ACCUMULATE ARGUMENTS - BEGIN
5047350566 {
@@ -50475,7 +50568,7 @@
5047550568 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5047650569 }
5047750570 // ACCUMULATE ARGUMENTS - END
50478- uint64_t return_to = 18446744073709549435LLU;
50571+ uint64_t return_to = 18446744073709549433LLU;
5047950572 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5048050573 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5048150574 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50484,7 +50577,7 @@
5048450577 state.addr = 839519665163075584LLU; // skip______
5048550578 break;
5048650579 }
50487- case 18446744073709549435LLU: // 99999999b5'''''''''''''''
50580+ case 18446744073709549433LLU: // 99999999b3'''''''''''''''
5048850581 {
5048950582 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5049050583 fprintf(stdout, "%s", " || ");
@@ -50494,7 +50587,7 @@
5049450587 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5049550588 }
5049650589 // ACCUMULATE ARGUMENTS - END
50497- uint64_t return_to = 18446744073709549434LLU;
50590+ uint64_t return_to = 18446744073709549432LLU;
5049850591 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5049950592 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5050050593 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50503,7 +50596,7 @@
5050350596 state.addr = 839519665163075584LLU; // skip______
5050450597 break;
5050550598 }
50506- case 18446744073709549434LLU: // 99999999b4'''''''''''''''
50599+ case 18446744073709549432LLU: // 99999999b2'''''''''''''''
5050750600 {
5050850601
5050950602 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50525,7 +50618,7 @@
5052550618 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5052650619 }
5052750620 // ACCUMULATE ARGUMENTS - END
50528- uint64_t return_to = 18446744073709549433LLU;
50621+ uint64_t return_to = 18446744073709549431LLU;
5052950622 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5053050623 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5053150624 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50534,7 +50627,7 @@
5053450627 state.addr = 23446349213393492LLU; // ASSERTINIT
5053550628 break;
5053650629 }
50537- case 18446744073709549433LLU: // 99999999b3'''''''''''''''
50630+ case 18446744073709549431LLU: // 99999999b1'''''''''''''''
5053850631 {
5053950632 {
5054050633 uint64_t arg = 0;
@@ -50613,7 +50706,7 @@
5061350706 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5061450707 }
5061550708 // ACCUMULATE ARGUMENTS - END
50616- uint64_t return_to = 18446744073709549432LLU;
50709+ uint64_t return_to = 18446744073709549430LLU;
5061750710 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5061850711 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5061950712 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50622,7 +50715,7 @@
5062250715 state.addr = 293363126232490310LLU; // PROCVARREF
5062350716 break;
5062450717 }
50625- case 18446744073709549432LLU: // 99999999b2'''''''''''''''
50718+ case 18446744073709549430LLU: // 99999999b0'''''''''''''''
5062650719 {
5062750720 // variable u64 initialize goes out of scope
5062850721 // emitted destructur for type u64
@@ -50643,7 +50736,7 @@
5064350736 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5064450737 }
5064550738 // ACCUMULATE ARGUMENTS - END
50646- uint64_t return_to = 18446744073709549431LLU;
50739+ uint64_t return_to = 18446744073709549429LLU;
5064750740 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5064850741 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5064950742 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50652,7 +50745,7 @@
5065250745 state.addr = 517555565476695680LLU; // assertu64_
5065350746 break;
5065450747 }
50655- case 18446744073709549431LLU: // 99999999b1'''''''''''''''
50748+ case 18446744073709549429LLU: // 99999999bz'''''''''''''''
5065650749 {
5065750750 // ACCUMULATE ARGUMENTS - BEGIN
5065850751 {
@@ -50660,7 +50753,7 @@
5066050753 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5066150754 }
5066250755 // ACCUMULATE ARGUMENTS - END
50663- uint64_t return_to = 18446744073709549430LLU;
50756+ uint64_t return_to = 18446744073709549428LLU;
5066450757 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5066550758 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5066650759 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50669,7 +50762,7 @@
5066950762 state.addr = 839519665163075584LLU; // skip______
5067050763 break;
5067150764 }
50672- case 18446744073709549430LLU: // 99999999b0'''''''''''''''
50765+ case 18446744073709549428LLU: // 99999999by'''''''''''''''
5067350766 {
5067450767 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5067550768 fprintf(stdout, "%s", ";");
@@ -50681,7 +50774,7 @@
5068150774 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5068250775 }
5068350776 // ACCUMULATE ARGUMENTS - END
50684- uint64_t return_to = 18446744073709549429LLU;
50777+ uint64_t return_to = 18446744073709549427LLU;
5068550778 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5068650779 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5068750780 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50690,7 +50783,7 @@
5069050783 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5069150784 break;
5069250785 }
50693- case 18446744073709549429LLU: // 99999999bz'''''''''''''''
50786+ case 18446744073709549427LLU: // 99999999bx'''''''''''''''
5069450787 {
5069550788 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5069650789 // variable type______ type______ goes out of scope
@@ -50701,7 +50794,7 @@
5070150794 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5070250795 }
5070350796 // ACCUMULATE ARGUMENTS - END
50704- uint64_t return_to = 18446744073709549428LLU;
50797+ uint64_t return_to = 18446744073709549426LLU;
5070550798 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5070650799 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5070750800 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50710,7 +50803,7 @@
5071050803 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5071150804 break;
5071250805 }
50713- case 18446744073709549428LLU: // 99999999by'''''''''''''''
50806+ case 18446744073709549426LLU: // 99999999bw'''''''''''''''
5071450807 {
5071550808 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5071650809 // variable u64 mutable___ goes out of scope
@@ -50722,10 +50815,10 @@
5072250815 // variable u64 id________ goes out of scope
5072350816 // emitted destructur for type u64
5072450817 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
50725- state.addr = 18446744073709549446LLU; // 99999999cF'''''''''''''''
50818+ state.addr = 18446744073709549444LLU; // 99999999cD'''''''''''''''
5072650819 break;
5072750820 }
50728- case 18446744073709549447LLU: // 99999999cG'''''''''''''''
50821+ case 18446744073709549445LLU: // 99999999cE'''''''''''''''
5072950822 {
5073050823
5073150824 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604158353408;
@@ -50736,11 +50829,11 @@
5073650829 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5073750830 }
5073850831 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50739- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549427LLU : 18446744073709549426LLU;
50832+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549425LLU : 18446744073709549424LLU;
5074050833 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5074150834 break;
5074250835 }
50743- case 18446744073709549427LLU: // 99999999bx'''''''''''''''
50836+ case 18446744073709549425LLU: // 99999999bv'''''''''''''''
5074450837 {
5074550838 {
5074650839 uint64_t arg = 0;
@@ -50767,7 +50860,7 @@
5076750860 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5076850861 }
5076950862 // ACCUMULATE ARGUMENTS - END
50770- uint64_t return_to = 18446744073709549424LLU;
50863+ uint64_t return_to = 18446744073709549422LLU;
5077150864 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5077250865 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5077350866 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50776,7 +50869,7 @@
5077650869 state.addr = 861504796319285248LLU; // typeu64___
5077750870 break;
5077850871 }
50779- case 18446744073709549424LLU: // 99999999bu'''''''''''''''
50872+ case 18446744073709549422LLU: // 99999999bs'''''''''''''''
5078050873 {
5078150874 {
5078250875 uint64_t arg = 0;
@@ -50801,7 +50894,7 @@
5080150894 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5080250895 }
5080350896 // ACCUMULATE ARGUMENTS - END
50804- uint64_t return_to = 18446744073709549422LLU;
50897+ uint64_t return_to = 18446744073709549420LLU;
5080550898 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5080650899 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5080750900 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50810,7 +50903,7 @@
5081050903 state.addr = 861504796319285248LLU; // typeu64___
5081150904 break;
5081250905 }
50813- case 18446744073709549422LLU: // 99999999bs'''''''''''''''
50906+ case 18446744073709549420LLU: // 99999999bq'''''''''''''''
5081450907 {
5081550908 {
5081650909 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -50830,7 +50923,7 @@
5083050923 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5083150924 }
5083250925 // ACCUMULATE ARGUMENTS - END
50833- uint64_t return_to = 18446744073709549423LLU;
50926+ uint64_t return_to = 18446744073709549421LLU;
5083450927 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5083550928 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5083650929 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50839,7 +50932,7 @@
5083950932 state.addr = 819859607768530944LLU; // resdest___
5084050933 break;
5084150934 }
50842- case 18446744073709549423LLU: // 99999999bt'''''''''''''''
50935+ case 18446744073709549421LLU: // 99999999br'''''''''''''''
5084350936 {
5084450937 // ACCUMULATE ARGUMENTS - BEGIN
5084550938 {
@@ -50859,7 +50952,7 @@
5085950952 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5086050953 }
5086150954 // ACCUMULATE ARGUMENTS - END
50862- uint64_t return_to = 18446744073709549421LLU;
50955+ uint64_t return_to = 18446744073709549419LLU;
5086350956 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5086450957 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5086550958 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50868,7 +50961,7 @@
5086850961 state.addr = 819857494882385920LLU; // res_u64___
5086950962 break;
5087050963 }
50871- case 18446744073709549421LLU: // 99999999br'''''''''''''''
50964+ case 18446744073709549419LLU: // 99999999bp'''''''''''''''
5087250965 {
5087350966 // ACCUMULATE ARGUMENTS - BEGIN
5087450967 {
@@ -50876,7 +50969,7 @@
5087650969 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5087750970 }
5087850971 // ACCUMULATE ARGUMENTS - END
50879- uint64_t return_to = 18446744073709549420LLU;
50972+ uint64_t return_to = 18446744073709549418LLU;
5088050973 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5088150974 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5088250975 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50885,7 +50978,7 @@
5088550978 state.addr = 839519665163075584LLU; // skip______
5088650979 break;
5088750980 }
50888- case 18446744073709549420LLU: // 99999999bq'''''''''''''''
50981+ case 18446744073709549418LLU: // 99999999bo'''''''''''''''
5088950982 {
5089050983 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5089150984 fprintf(stdout, "%s", "\n ");
@@ -50911,7 +51004,7 @@
5091151004 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5091251005 }
5091351006 // ACCUMULATE ARGUMENTS - END
50914- uint64_t return_to = 18446744073709549419LLU;
51007+ uint64_t return_to = 18446744073709549417LLU;
5091551008 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5091651009 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5091751010 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50920,7 +51013,7 @@
5092051013 state.addr = 587881357514113024LLU; // emitpar___
5092151014 break;
5092251015 }
50923- case 18446744073709549419LLU: // 99999999bp'''''''''''''''
51016+ case 18446744073709549417LLU: // 99999999bn'''''''''''''''
5092451017 {
5092551018 fprintf(stdout, "%s", " = ");
5092651019 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50929,7 +51022,7 @@
5092951022 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5093051023 }
5093151024 // ACCUMULATE ARGUMENTS - END
50932- uint64_t return_to = 18446744073709549418LLU;
51025+ uint64_t return_to = 18446744073709549416LLU;
5093351026 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5093451027 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5093551028 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50938,7 +51031,7 @@
5093851031 state.addr = 839519665163075584LLU; // skip______
5093951032 break;
5094051033 }
50941- case 18446744073709549418LLU: // 99999999bo'''''''''''''''
51034+ case 18446744073709549416LLU: // 99999999bm'''''''''''''''
5094251035 {
5094351036
5094451037 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50960,7 +51053,7 @@
5096051053 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5096151054 }
5096251055 // ACCUMULATE ARGUMENTS - END
50963- uint64_t return_to = 18446744073709549417LLU;
51056+ uint64_t return_to = 18446744073709549415LLU;
5096451057 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5096551058 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5096651059 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50969,7 +51062,7 @@
5096951062 state.addr = 23446349213393492LLU; // ASSERTINIT
5097051063 break;
5097151064 }
50972- case 18446744073709549417LLU: // 99999999bn'''''''''''''''
51065+ case 18446744073709549415LLU: // 99999999bl'''''''''''''''
5097351066 {
5097451067 {
5097551068 uint64_t arg = 0;
@@ -51048,7 +51141,7 @@
5104851141 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5104951142 }
5105051143 // ACCUMULATE ARGUMENTS - END
51051- uint64_t return_to = 18446744073709549416LLU;
51144+ uint64_t return_to = 18446744073709549414LLU;
5105251145 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5105351146 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5105451147 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51057,7 +51150,7 @@
5105751150 state.addr = 293363126232490310LLU; // PROCVARREF
5105851151 break;
5105951152 }
51060- case 18446744073709549416LLU: // 99999999bm'''''''''''''''
51153+ case 18446744073709549414LLU: // 99999999bk'''''''''''''''
5106151154 {
5106251155 // variable u64 initialize goes out of scope
5106351156 // emitted destructur for type u64
@@ -51078,7 +51171,7 @@
5107851171 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5107951172 }
5108051173 // ACCUMULATE ARGUMENTS - END
51081- uint64_t return_to = 18446744073709549415LLU;
51174+ uint64_t return_to = 18446744073709549413LLU;
5108251175 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5108351176 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5108451177 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51087,7 +51180,7 @@
5108751180 state.addr = 517555565476695680LLU; // assertu64_
5108851181 break;
5108951182 }
51090- case 18446744073709549415LLU: // 99999999bl'''''''''''''''
51183+ case 18446744073709549413LLU: // 99999999bj'''''''''''''''
5109151184 {
5109251185 // ACCUMULATE ARGUMENTS - BEGIN
5109351186 {
@@ -51095,7 +51188,7 @@
5109551188 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5109651189 }
5109751190 // ACCUMULATE ARGUMENTS - END
51098- uint64_t return_to = 18446744073709549414LLU;
51191+ uint64_t return_to = 18446744073709549412LLU;
5109951192 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5110051193 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5110151194 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51104,7 +51197,7 @@
5110451197 state.addr = 839519665163075584LLU; // skip______
5110551198 break;
5110651199 }
51107- case 18446744073709549414LLU: // 99999999bk'''''''''''''''
51200+ case 18446744073709549412LLU: // 99999999bi'''''''''''''''
5110851201 {
5110951202 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5111051203 fprintf(stdout, "%s", " << ");
@@ -51114,7 +51207,7 @@
5111451207 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5111551208 }
5111651209 // ACCUMULATE ARGUMENTS - END
51117- uint64_t return_to = 18446744073709549413LLU;
51210+ uint64_t return_to = 18446744073709549411LLU;
5111851211 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5111951212 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5112051213 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51123,7 +51216,7 @@
5112351216 state.addr = 839519665163075584LLU; // skip______
5112451217 break;
5112551218 }
51126- case 18446744073709549413LLU: // 99999999bj'''''''''''''''
51219+ case 18446744073709549411LLU: // 99999999bh'''''''''''''''
5112751220 {
5112851221
5112951222 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51145,7 +51238,7 @@
5114551238 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5114651239 }
5114751240 // ACCUMULATE ARGUMENTS - END
51148- uint64_t return_to = 18446744073709549412LLU;
51241+ uint64_t return_to = 18446744073709549410LLU;
5114951242 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5115051243 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5115151244 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51154,7 +51247,7 @@
5115451247 state.addr = 23446349213393492LLU; // ASSERTINIT
5115551248 break;
5115651249 }
51157- case 18446744073709549412LLU: // 99999999bi'''''''''''''''
51250+ case 18446744073709549410LLU: // 99999999bg'''''''''''''''
5115851251 {
5115951252 {
5116051253 uint64_t arg = 0;
@@ -51233,7 +51326,7 @@
5123351326 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5123451327 }
5123551328 // ACCUMULATE ARGUMENTS - END
51236- uint64_t return_to = 18446744073709549411LLU;
51329+ uint64_t return_to = 18446744073709549409LLU;
5123751330 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5123851331 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5123951332 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51242,7 +51335,7 @@
5124251335 state.addr = 293363126232490310LLU; // PROCVARREF
5124351336 break;
5124451337 }
51245- case 18446744073709549411LLU: // 99999999bh'''''''''''''''
51338+ case 18446744073709549409LLU: // 99999999bf'''''''''''''''
5124651339 {
5124751340 // variable u64 initialize goes out of scope
5124851341 // emitted destructur for type u64
@@ -51263,7 +51356,7 @@
5126351356 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5126451357 }
5126551358 // ACCUMULATE ARGUMENTS - END
51266- uint64_t return_to = 18446744073709549410LLU;
51359+ uint64_t return_to = 18446744073709549408LLU;
5126751360 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5126851361 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5126951362 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51272,7 +51365,7 @@
5127251365 state.addr = 517555565476695680LLU; // assertu64_
5127351366 break;
5127451367 }
51275- case 18446744073709549410LLU: // 99999999bg'''''''''''''''
51368+ case 18446744073709549408LLU: // 99999999be'''''''''''''''
5127651369 {
5127751370 // ACCUMULATE ARGUMENTS - BEGIN
5127851371 {
@@ -51280,7 +51373,7 @@
5128051373 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5128151374 }
5128251375 // ACCUMULATE ARGUMENTS - END
51283- uint64_t return_to = 18446744073709549409LLU;
51376+ uint64_t return_to = 18446744073709549407LLU;
5128451377 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5128551378 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5128651379 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51289,7 +51382,7 @@
5128951382 state.addr = 839519665163075584LLU; // skip______
5129051383 break;
5129151384 }
51292- case 18446744073709549409LLU: // 99999999bf'''''''''''''''
51385+ case 18446744073709549407LLU: // 99999999bd'''''''''''''''
5129351386 {
5129451387 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5129551388 fprintf(stdout, "%s", ";");
@@ -51301,7 +51394,7 @@
5130151394 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5130251395 }
5130351396 // ACCUMULATE ARGUMENTS - END
51304- uint64_t return_to = 18446744073709549408LLU;
51397+ uint64_t return_to = 18446744073709549406LLU;
5130551398 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5130651399 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5130751400 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51310,7 +51403,7 @@
5131051403 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5131151404 break;
5131251405 }
51313- case 18446744073709549408LLU: // 99999999be'''''''''''''''
51406+ case 18446744073709549406LLU: // 99999999bc'''''''''''''''
5131451407 {
5131551408 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5131651409 // variable type______ type______ goes out of scope
@@ -51321,7 +51414,7 @@
5132151414 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5132251415 }
5132351416 // ACCUMULATE ARGUMENTS - END
51324- uint64_t return_to = 18446744073709549407LLU;
51417+ uint64_t return_to = 18446744073709549405LLU;
5132551418 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5132651419 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5132751420 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51330,7 +51423,7 @@
5133051423 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5133151424 break;
5133251425 }
51333- case 18446744073709549407LLU: // 99999999bd'''''''''''''''
51426+ case 18446744073709549405LLU: // 99999999bb'''''''''''''''
5133451427 {
5133551428 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5133651429 // variable u64 mutable___ goes out of scope
@@ -51342,10 +51435,10 @@
5134251435 // variable u64 id________ goes out of scope
5134351436 // emitted destructur for type u64
5134451437 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
51345- state.addr = 18446744073709549425LLU; // 99999999bv'''''''''''''''
51438+ state.addr = 18446744073709549423LLU; // 99999999bt'''''''''''''''
5134651439 break;
5134751440 }
51348- case 18446744073709549426LLU: // 99999999bw'''''''''''''''
51441+ case 18446744073709549424LLU: // 99999999bu'''''''''''''''
5134951442 {
5135051443
5135151444 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604259016704;
@@ -51356,11 +51449,11 @@
5135651449 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5135751450 }
5135851451 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51359- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549406LLU : 18446744073709549405LLU;
51452+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549404LLU : 18446744073709549403LLU;
5136051453 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5136151454 break;
5136251455 }
51363- case 18446744073709549406LLU: // 99999999bc'''''''''''''''
51456+ case 18446744073709549404LLU: // 99999999ba'''''''''''''''
5136451457 {
5136551458 {
5136651459 uint64_t arg = 0;
@@ -51387,7 +51480,7 @@
5138751480 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5138851481 }
5138951482 // ACCUMULATE ARGUMENTS - END
51390- uint64_t return_to = 18446744073709549403LLU;
51483+ uint64_t return_to = 18446744073709549401LLU;
5139151484 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5139251485 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5139351486 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51396,7 +51489,7 @@
5139651489 state.addr = 861504796319285248LLU; // typeu64___
5139751490 break;
5139851491 }
51399- case 18446744073709549403LLU: // 99999999b$'''''''''''''''
51492+ case 18446744073709549401LLU: // 99999999bY'''''''''''''''
5140051493 {
5140151494 {
5140251495 uint64_t arg = 0;
@@ -51421,7 +51514,7 @@
5142151514 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5142251515 }
5142351516 // ACCUMULATE ARGUMENTS - END
51424- uint64_t return_to = 18446744073709549401LLU;
51517+ uint64_t return_to = 18446744073709549399LLU;
5142551518 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5142651519 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5142751520 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51430,7 +51523,7 @@
5143051523 state.addr = 861504796319285248LLU; // typeu64___
5143151524 break;
5143251525 }
51433- case 18446744073709549401LLU: // 99999999bY'''''''''''''''
51526+ case 18446744073709549399LLU: // 99999999bW'''''''''''''''
5143451527 {
5143551528 {
5143651529 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -51450,7 +51543,7 @@
5145051543 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5145151544 }
5145251545 // ACCUMULATE ARGUMENTS - END
51453- uint64_t return_to = 18446744073709549402LLU;
51546+ uint64_t return_to = 18446744073709549400LLU;
5145451547 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5145551548 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5145651549 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51459,7 +51552,7 @@
5145951552 state.addr = 819859607768530944LLU; // resdest___
5146051553 break;
5146151554 }
51462- case 18446744073709549402LLU: // 99999999bZ'''''''''''''''
51555+ case 18446744073709549400LLU: // 99999999bX'''''''''''''''
5146351556 {
5146451557 // ACCUMULATE ARGUMENTS - BEGIN
5146551558 {
@@ -51479,7 +51572,7 @@
5147951572 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5148051573 }
5148151574 // ACCUMULATE ARGUMENTS - END
51482- uint64_t return_to = 18446744073709549400LLU;
51575+ uint64_t return_to = 18446744073709549398LLU;
5148351576 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5148451577 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5148551578 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51488,7 +51581,7 @@
5148851581 state.addr = 819857494882385920LLU; // res_u64___
5148951582 break;
5149051583 }
51491- case 18446744073709549400LLU: // 99999999bX'''''''''''''''
51584+ case 18446744073709549398LLU: // 99999999bV'''''''''''''''
5149251585 {
5149351586 // ACCUMULATE ARGUMENTS - BEGIN
5149451587 {
@@ -51496,7 +51589,7 @@
5149651589 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5149751590 }
5149851591 // ACCUMULATE ARGUMENTS - END
51499- uint64_t return_to = 18446744073709549399LLU;
51592+ uint64_t return_to = 18446744073709549397LLU;
5150051593 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5150151594 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5150251595 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51505,7 +51598,7 @@
5150551598 state.addr = 839519665163075584LLU; // skip______
5150651599 break;
5150751600 }
51508- case 18446744073709549399LLU: // 99999999bW'''''''''''''''
51601+ case 18446744073709549397LLU: // 99999999bU'''''''''''''''
5150951602 {
5151051603 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5151151604 fprintf(stdout, "%s", "\n ");
@@ -51531,7 +51624,7 @@
5153151624 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5153251625 }
5153351626 // ACCUMULATE ARGUMENTS - END
51534- uint64_t return_to = 18446744073709549398LLU;
51627+ uint64_t return_to = 18446744073709549396LLU;
5153551628 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5153651629 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5153751630 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51540,7 +51633,7 @@
5154051633 state.addr = 587881357514113024LLU; // emitpar___
5154151634 break;
5154251635 }
51543- case 18446744073709549398LLU: // 99999999bV'''''''''''''''
51636+ case 18446744073709549396LLU: // 99999999bT'''''''''''''''
5154451637 {
5154551638 fprintf(stdout, "%s", " = ");
5154651639 // ACCUMULATE ARGUMENTS - BEGIN
@@ -51549,7 +51642,7 @@
5154951642 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5155051643 }
5155151644 // ACCUMULATE ARGUMENTS - END
51552- uint64_t return_to = 18446744073709549397LLU;
51645+ uint64_t return_to = 18446744073709549395LLU;
5155351646 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5155451647 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5155551648 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51558,7 +51651,7 @@
5155851651 state.addr = 839519665163075584LLU; // skip______
5155951652 break;
5156051653 }
51561- case 18446744073709549397LLU: // 99999999bU'''''''''''''''
51654+ case 18446744073709549395LLU: // 99999999bS'''''''''''''''
5156251655 {
5156351656
5156451657 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51580,7 +51673,7 @@
5158051673 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5158151674 }
5158251675 // ACCUMULATE ARGUMENTS - END
51583- uint64_t return_to = 18446744073709549396LLU;
51676+ uint64_t return_to = 18446744073709549394LLU;
5158451677 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5158551678 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5158651679 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51589,7 +51682,7 @@
5158951682 state.addr = 23446349213393492LLU; // ASSERTINIT
5159051683 break;
5159151684 }
51592- case 18446744073709549396LLU: // 99999999bT'''''''''''''''
51685+ case 18446744073709549394LLU: // 99999999bR'''''''''''''''
5159351686 {
5159451687 {
5159551688 uint64_t arg = 0;
@@ -51668,7 +51761,7 @@
5166851761 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5166951762 }
5167051763 // ACCUMULATE ARGUMENTS - END
51671- uint64_t return_to = 18446744073709549395LLU;
51764+ uint64_t return_to = 18446744073709549393LLU;
5167251765 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5167351766 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5167451767 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51677,7 +51770,7 @@
5167751770 state.addr = 293363126232490310LLU; // PROCVARREF
5167851771 break;
5167951772 }
51680- case 18446744073709549395LLU: // 99999999bS'''''''''''''''
51773+ case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
5168151774 {
5168251775 // variable u64 initialize goes out of scope
5168351776 // emitted destructur for type u64
@@ -51698,7 +51791,7 @@
5169851791 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5169951792 }
5170051793 // ACCUMULATE ARGUMENTS - END
51701- uint64_t return_to = 18446744073709549394LLU;
51794+ uint64_t return_to = 18446744073709549392LLU;
5170251795 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5170351796 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5170451797 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51707,7 +51800,7 @@
5170751800 state.addr = 517555565476695680LLU; // assertu64_
5170851801 break;
5170951802 }
51710- case 18446744073709549394LLU: // 99999999bR'''''''''''''''
51803+ case 18446744073709549392LLU: // 99999999bP'''''''''''''''
5171151804 {
5171251805 // ACCUMULATE ARGUMENTS - BEGIN
5171351806 {
@@ -51715,7 +51808,7 @@
5171551808 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5171651809 }
5171751810 // ACCUMULATE ARGUMENTS - END
51718- uint64_t return_to = 18446744073709549393LLU;
51811+ uint64_t return_to = 18446744073709549391LLU;
5171951812 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5172051813 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5172151814 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51724,7 +51817,7 @@
5172451817 state.addr = 839519665163075584LLU; // skip______
5172551818 break;
5172651819 }
51727- case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
51820+ case 18446744073709549391LLU: // 99999999bO'''''''''''''''
5172851821 {
5172951822 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5173051823 fprintf(stdout, "%s", " >> ");
@@ -51734,7 +51827,7 @@
5173451827 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5173551828 }
5173651829 // ACCUMULATE ARGUMENTS - END
51737- uint64_t return_to = 18446744073709549392LLU;
51830+ uint64_t return_to = 18446744073709549390LLU;
5173851831 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5173951832 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5174051833 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51743,7 +51836,7 @@
5174351836 state.addr = 839519665163075584LLU; // skip______
5174451837 break;
5174551838 }
51746- case 18446744073709549392LLU: // 99999999bP'''''''''''''''
51839+ case 18446744073709549390LLU: // 99999999bN'''''''''''''''
5174751840 {
5174851841
5174951842 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51765,7 +51858,7 @@
5176551858 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5176651859 }
5176751860 // ACCUMULATE ARGUMENTS - END
51768- uint64_t return_to = 18446744073709549391LLU;
51861+ uint64_t return_to = 18446744073709549389LLU;
5176951862 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5177051863 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5177151864 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51774,7 +51867,7 @@
5177451867 state.addr = 23446349213393492LLU; // ASSERTINIT
5177551868 break;
5177651869 }
51777- case 18446744073709549391LLU: // 99999999bO'''''''''''''''
51870+ case 18446744073709549389LLU: // 99999999bM'''''''''''''''
5177851871 {
5177951872 {
5178051873 uint64_t arg = 0;
@@ -51853,7 +51946,7 @@
5185351946 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5185451947 }
5185551948 // ACCUMULATE ARGUMENTS - END
51856- uint64_t return_to = 18446744073709549390LLU;
51949+ uint64_t return_to = 18446744073709549388LLU;
5185751950 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5185851951 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5185951952 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51862,7 +51955,7 @@
5186251955 state.addr = 293363126232490310LLU; // PROCVARREF
5186351956 break;
5186451957 }
51865- case 18446744073709549390LLU: // 99999999bN'''''''''''''''
51958+ case 18446744073709549388LLU: // 99999999bL'''''''''''''''
5186651959 {
5186751960 // variable u64 initialize goes out of scope
5186851961 // emitted destructur for type u64
@@ -51883,7 +51976,7 @@
5188351976 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5188451977 }
5188551978 // ACCUMULATE ARGUMENTS - END
51886- uint64_t return_to = 18446744073709549389LLU;
51979+ uint64_t return_to = 18446744073709549387LLU;
5188751980 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5188851981 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5188951982 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51892,7 +51985,7 @@
5189251985 state.addr = 517555565476695680LLU; // assertu64_
5189351986 break;
5189451987 }
51895- case 18446744073709549389LLU: // 99999999bM'''''''''''''''
51988+ case 18446744073709549387LLU: // 99999999bK'''''''''''''''
5189651989 {
5189751990 // ACCUMULATE ARGUMENTS - BEGIN
5189851991 {
@@ -51900,7 +51993,7 @@
5190051993 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5190151994 }
5190251995 // ACCUMULATE ARGUMENTS - END
51903- uint64_t return_to = 18446744073709549388LLU;
51996+ uint64_t return_to = 18446744073709549386LLU;
5190451997 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5190551998 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5190651999 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51909,7 +52002,7 @@
5190952002 state.addr = 839519665163075584LLU; // skip______
5191052003 break;
5191152004 }
51912- case 18446744073709549388LLU: // 99999999bL'''''''''''''''
52005+ case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
5191352006 {
5191452007 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5191552008 fprintf(stdout, "%s", ";");
@@ -51921,7 +52014,7 @@
5192152014 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5192252015 }
5192352016 // ACCUMULATE ARGUMENTS - END
51924- uint64_t return_to = 18446744073709549387LLU;
52017+ uint64_t return_to = 18446744073709549385LLU;
5192552018 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5192652019 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5192752020 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51930,7 +52023,7 @@
5193052023 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5193152024 break;
5193252025 }
51933- case 18446744073709549387LLU: // 99999999bK'''''''''''''''
52026+ case 18446744073709549385LLU: // 99999999bI'''''''''''''''
5193452027 {
5193552028 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5193652029 // variable type______ type______ goes out of scope
@@ -51941,7 +52034,7 @@
5194152034 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5194252035 }
5194352036 // ACCUMULATE ARGUMENTS - END
51944- uint64_t return_to = 18446744073709549386LLU;
52037+ uint64_t return_to = 18446744073709549384LLU;
5194552038 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5194652039 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5194752040 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51950,7 +52043,7 @@
5195052043 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5195152044 break;
5195252045 }
51953- case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
52046+ case 18446744073709549384LLU: // 99999999bH'''''''''''''''
5195452047 {
5195552048 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5195652049 // variable u64 mutable___ goes out of scope
@@ -51962,10 +52055,10 @@
5196252055 // variable u64 id________ goes out of scope
5196352056 // emitted destructur for type u64
5196452057 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
51965- state.addr = 18446744073709549404LLU; // 99999999ba'''''''''''''''
52058+ state.addr = 18446744073709549402LLU; // 99999999bZ'''''''''''''''
5196652059 break;
5196752060 }
51968- case 18446744073709549405LLU: // 99999999bb'''''''''''''''
52061+ case 18446744073709549403LLU: // 99999999b$'''''''''''''''
5196952062 {
5197052063
5197152064 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 513265221985370112;
@@ -51976,11 +52069,11 @@
5197652069 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5197752070 }
5197852071 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51979- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549385LLU : 18446744073709549384LLU;
52072+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549383LLU : 18446744073709549382LLU;
5198052073 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5198152074 break;
5198252075 }
51983- case 18446744073709549385LLU: // 99999999bI'''''''''''''''
52076+ case 18446744073709549383LLU: // 99999999bG'''''''''''''''
5198452077 {
5198552078 {
5198652079 uint64_t arg = 0;
@@ -52007,7 +52100,7 @@
5200752100 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5200852101 }
5200952102 // ACCUMULATE ARGUMENTS - END
52010- uint64_t return_to = 18446744073709549382LLU;
52103+ uint64_t return_to = 18446744073709549380LLU;
5201152104 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5201252105 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5201352106 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52016,7 +52109,7 @@
5201652109 state.addr = 861504796319285248LLU; // typeu64___
5201752110 break;
5201852111 }
52019- case 18446744073709549382LLU: // 99999999bF'''''''''''''''
52112+ case 18446744073709549380LLU: // 99999999bD'''''''''''''''
5202052113 {
5202152114 {
5202252115 uint64_t arg = 0;
@@ -52041,7 +52134,7 @@
5204152134 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5204252135 }
5204352136 // ACCUMULATE ARGUMENTS - END
52044- uint64_t return_to = 18446744073709549380LLU;
52137+ uint64_t return_to = 18446744073709549378LLU;
5204552138 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5204652139 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5204752140 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52050,7 +52143,7 @@
5205052143 state.addr = 861504796319285248LLU; // typeu64___
5205152144 break;
5205252145 }
52053- case 18446744073709549380LLU: // 99999999bD'''''''''''''''
52146+ case 18446744073709549378LLU: // 99999999bB'''''''''''''''
5205452147 {
5205552148 {
5205652149 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -52070,7 +52163,7 @@
5207052163 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5207152164 }
5207252165 // ACCUMULATE ARGUMENTS - END
52073- uint64_t return_to = 18446744073709549381LLU;
52166+ uint64_t return_to = 18446744073709549379LLU;
5207452167 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5207552168 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5207652169 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52079,7 +52172,7 @@
5207952172 state.addr = 819859607768530944LLU; // resdest___
5208052173 break;
5208152174 }
52082- case 18446744073709549381LLU: // 99999999bE'''''''''''''''
52175+ case 18446744073709549379LLU: // 99999999bC'''''''''''''''
5208352176 {
5208452177 // ACCUMULATE ARGUMENTS - BEGIN
5208552178 {
@@ -52099,7 +52192,7 @@
5209952192 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5210052193 }
5210152194 // ACCUMULATE ARGUMENTS - END
52102- uint64_t return_to = 18446744073709549379LLU;
52195+ uint64_t return_to = 18446744073709549377LLU;
5210352196 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5210452197 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5210552198 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52108,7 +52201,7 @@
5210852201 state.addr = 819857494882385920LLU; // res_u64___
5210952202 break;
5211052203 }
52111- case 18446744073709549379LLU: // 99999999bC'''''''''''''''
52204+ case 18446744073709549377LLU: // 99999999bA'''''''''''''''
5211252205 {
5211352206 // ACCUMULATE ARGUMENTS - BEGIN
5211452207 {
@@ -52116,7 +52209,7 @@
5211652209 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5211752210 }
5211852211 // ACCUMULATE ARGUMENTS - END
52119- uint64_t return_to = 18446744073709549378LLU;
52212+ uint64_t return_to = 18446744073709549376LLU;
5212052213 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5212152214 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5212252215 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52125,7 +52218,7 @@
5212552218 state.addr = 839519665163075584LLU; // skip______
5212652219 break;
5212752220 }
52128- case 18446744073709549378LLU: // 99999999bB'''''''''''''''
52221+ case 18446744073709549376LLU: // 99999999b_'''''''''''''''
5212952222 {
5213052223 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5213152224 fprintf(stdout, "%s", "\n ");
@@ -52151,7 +52244,7 @@
5215152244 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5215252245 }
5215352246 // ACCUMULATE ARGUMENTS - END
52154- uint64_t return_to = 18446744073709549377LLU;
52247+ uint64_t return_to = 18446744073709549375LLU;
5215552248 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5215652249 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5215752250 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52160,7 +52253,7 @@
5216052253 state.addr = 587881357514113024LLU; // emitpar___
5216152254 break;
5216252255 }
52163- case 18446744073709549377LLU: // 99999999bA'''''''''''''''
52256+ case 18446744073709549375LLU: // 99999999a9'''''''''''''''
5216452257 {
5216552258 fprintf(stdout, "%s", " = ");
5216652259 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52169,7 +52262,7 @@
5216952262 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5217052263 }
5217152264 // ACCUMULATE ARGUMENTS - END
52172- uint64_t return_to = 18446744073709549376LLU;
52265+ uint64_t return_to = 18446744073709549374LLU;
5217352266 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5217452267 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5217552268 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52178,7 +52271,7 @@
5217852271 state.addr = 839519665163075584LLU; // skip______
5217952272 break;
5218052273 }
52181- case 18446744073709549376LLU: // 99999999b_'''''''''''''''
52274+ case 18446744073709549374LLU: // 99999999a8'''''''''''''''
5218252275 {
5218352276
5218452277 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52200,7 +52293,7 @@
5220052293 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5220152294 }
5220252295 // ACCUMULATE ARGUMENTS - END
52203- uint64_t return_to = 18446744073709549375LLU;
52296+ uint64_t return_to = 18446744073709549373LLU;
5220452297 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5220552298 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5220652299 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52209,7 +52302,7 @@
5220952302 state.addr = 23446349213393492LLU; // ASSERTINIT
5221052303 break;
5221152304 }
52212- case 18446744073709549375LLU: // 99999999a9'''''''''''''''
52305+ case 18446744073709549373LLU: // 99999999a7'''''''''''''''
5221352306 {
5221452307 {
5221552308 uint64_t arg = 0;
@@ -52288,7 +52381,7 @@
5228852381 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5228952382 }
5229052383 // ACCUMULATE ARGUMENTS - END
52291- uint64_t return_to = 18446744073709549374LLU;
52384+ uint64_t return_to = 18446744073709549372LLU;
5229252385 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5229352386 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5229452387 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52297,7 +52390,7 @@
5229752390 state.addr = 293363126232490310LLU; // PROCVARREF
5229852391 break;
5229952392 }
52300- case 18446744073709549374LLU: // 99999999a8'''''''''''''''
52393+ case 18446744073709549372LLU: // 99999999a6'''''''''''''''
5230152394 {
5230252395 // variable u64 initialize goes out of scope
5230352396 // emitted destructur for type u64
@@ -52318,7 +52411,7 @@
5231852411 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5231952412 }
5232052413 // ACCUMULATE ARGUMENTS - END
52321- uint64_t return_to = 18446744073709549373LLU;
52414+ uint64_t return_to = 18446744073709549371LLU;
5232252415 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5232352416 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5232452417 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52327,7 +52420,7 @@
5232752420 state.addr = 517555565476695680LLU; // assertu64_
5232852421 break;
5232952422 }
52330- case 18446744073709549373LLU: // 99999999a7'''''''''''''''
52423+ case 18446744073709549371LLU: // 99999999a5'''''''''''''''
5233152424 {
5233252425 // ACCUMULATE ARGUMENTS - BEGIN
5233352426 {
@@ -52335,7 +52428,7 @@
5233552428 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5233652429 }
5233752430 // ACCUMULATE ARGUMENTS - END
52338- uint64_t return_to = 18446744073709549372LLU;
52431+ uint64_t return_to = 18446744073709549370LLU;
5233952432 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5234052433 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5234152434 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52344,7 +52437,7 @@
5234452437 state.addr = 839519665163075584LLU; // skip______
5234552438 break;
5234652439 }
52347- case 18446744073709549372LLU: // 99999999a6'''''''''''''''
52440+ case 18446744073709549370LLU: // 99999999a4'''''''''''''''
5234852441 {
5234952442 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5235052443 fprintf(stdout, "%s", " + ");
@@ -52354,7 +52447,7 @@
5235452447 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5235552448 }
5235652449 // ACCUMULATE ARGUMENTS - END
52357- uint64_t return_to = 18446744073709549371LLU;
52450+ uint64_t return_to = 18446744073709549369LLU;
5235852451 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5235952452 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5236052453 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52363,7 +52456,7 @@
5236352456 state.addr = 839519665163075584LLU; // skip______
5236452457 break;
5236552458 }
52366- case 18446744073709549371LLU: // 99999999a5'''''''''''''''
52459+ case 18446744073709549369LLU: // 99999999a3'''''''''''''''
5236752460 {
5236852461
5236952462 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52385,7 +52478,7 @@
5238552478 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5238652479 }
5238752480 // ACCUMULATE ARGUMENTS - END
52388- uint64_t return_to = 18446744073709549370LLU;
52481+ uint64_t return_to = 18446744073709549368LLU;
5238952482 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5239052483 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5239152484 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52394,7 +52487,7 @@
5239452487 state.addr = 23446349213393492LLU; // ASSERTINIT
5239552488 break;
5239652489 }
52397- case 18446744073709549370LLU: // 99999999a4'''''''''''''''
52490+ case 18446744073709549368LLU: // 99999999a2'''''''''''''''
5239852491 {
5239952492 {
5240052493 uint64_t arg = 0;
@@ -52473,7 +52566,7 @@
5247352566 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5247452567 }
5247552568 // ACCUMULATE ARGUMENTS - END
52476- uint64_t return_to = 18446744073709549369LLU;
52569+ uint64_t return_to = 18446744073709549367LLU;
5247752570 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5247852571 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5247952572 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52482,7 +52575,7 @@
5248252575 state.addr = 293363126232490310LLU; // PROCVARREF
5248352576 break;
5248452577 }
52485- case 18446744073709549369LLU: // 99999999a3'''''''''''''''
52578+ case 18446744073709549367LLU: // 99999999a1'''''''''''''''
5248652579 {
5248752580 // variable u64 initialize goes out of scope
5248852581 // emitted destructur for type u64
@@ -52503,7 +52596,7 @@
5250352596 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5250452597 }
5250552598 // ACCUMULATE ARGUMENTS - END
52506- uint64_t return_to = 18446744073709549368LLU;
52599+ uint64_t return_to = 18446744073709549366LLU;
5250752600 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5250852601 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5250952602 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52512,7 +52605,7 @@
5251252605 state.addr = 517555565476695680LLU; // assertu64_
5251352606 break;
5251452607 }
52515- case 18446744073709549368LLU: // 99999999a2'''''''''''''''
52608+ case 18446744073709549366LLU: // 99999999a0'''''''''''''''
5251652609 {
5251752610 // ACCUMULATE ARGUMENTS - BEGIN
5251852611 {
@@ -52520,7 +52613,7 @@
5252052613 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5252152614 }
5252252615 // ACCUMULATE ARGUMENTS - END
52523- uint64_t return_to = 18446744073709549367LLU;
52616+ uint64_t return_to = 18446744073709549365LLU;
5252452617 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5252552618 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5252652619 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52529,7 +52622,7 @@
5252952622 state.addr = 839519665163075584LLU; // skip______
5253052623 break;
5253152624 }
52532- case 18446744073709549367LLU: // 99999999a1'''''''''''''''
52625+ case 18446744073709549365LLU: // 99999999az'''''''''''''''
5253352626 {
5253452627 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5253552628 fprintf(stdout, "%s", ";");
@@ -52541,7 +52634,7 @@
5254152634 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5254252635 }
5254352636 // ACCUMULATE ARGUMENTS - END
52544- uint64_t return_to = 18446744073709549366LLU;
52637+ uint64_t return_to = 18446744073709549364LLU;
5254552638 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5254652639 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5254752640 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52550,7 +52643,7 @@
5255052643 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5255152644 break;
5255252645 }
52553- case 18446744073709549366LLU: // 99999999a0'''''''''''''''
52646+ case 18446744073709549364LLU: // 99999999ay'''''''''''''''
5255452647 {
5255552648 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5255652649 // variable type______ type______ goes out of scope
@@ -52561,7 +52654,7 @@
5256152654 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5256252655 }
5256352656 // ACCUMULATE ARGUMENTS - END
52564- uint64_t return_to = 18446744073709549365LLU;
52657+ uint64_t return_to = 18446744073709549363LLU;
5256552658 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5256652659 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5256752660 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52570,7 +52663,7 @@
5257052663 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5257152664 break;
5257252665 }
52573- case 18446744073709549365LLU: // 99999999az'''''''''''''''
52666+ case 18446744073709549363LLU: // 99999999ax'''''''''''''''
5257452667 {
5257552668 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5257652669 // variable u64 mutable___ goes out of scope
@@ -52582,10 +52675,10 @@
5258252675 // variable u64 id________ goes out of scope
5258352676 // emitted destructur for type u64
5258452677 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
52585- state.addr = 18446744073709549383LLU; // 99999999bG'''''''''''''''
52678+ state.addr = 18446744073709549381LLU; // 99999999bE'''''''''''''''
5258652679 break;
5258752680 }
52588- case 18446744073709549384LLU: // 99999999bH'''''''''''''''
52681+ case 18446744073709549382LLU: // 99999999bF'''''''''''''''
5258952682 {
5259052683
5259152684 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 842300673667104768;
@@ -52596,11 +52689,11 @@
5259652689 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5259752690 }
5259852691 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
52599- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549364LLU : 18446744073709549363LLU;
52692+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549362LLU : 18446744073709549361LLU;
5260052693 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5260152694 break;
5260252695 }
52603- case 18446744073709549364LLU: // 99999999ay'''''''''''''''
52696+ case 18446744073709549362LLU: // 99999999aw'''''''''''''''
5260452697 {
5260552698 {
5260652699 uint64_t arg = 0;
@@ -52627,7 +52720,7 @@
5262752720 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5262852721 }
5262952722 // ACCUMULATE ARGUMENTS - END
52630- uint64_t return_to = 18446744073709549361LLU;
52723+ uint64_t return_to = 18446744073709549359LLU;
5263152724 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5263252725 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5263352726 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52636,7 +52729,7 @@
5263652729 state.addr = 861504796319285248LLU; // typeu64___
5263752730 break;
5263852731 }
52639- case 18446744073709549361LLU: // 99999999av'''''''''''''''
52732+ case 18446744073709549359LLU: // 99999999at'''''''''''''''
5264052733 {
5264152734 {
5264252735 uint64_t arg = 0;
@@ -52661,7 +52754,7 @@
5266152754 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5266252755 }
5266352756 // ACCUMULATE ARGUMENTS - END
52664- uint64_t return_to = 18446744073709549359LLU;
52757+ uint64_t return_to = 18446744073709549357LLU;
5266552758 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5266652759 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5266752760 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52670,7 +52763,7 @@
5267052763 state.addr = 861504796319285248LLU; // typeu64___
5267152764 break;
5267252765 }
52673- case 18446744073709549359LLU: // 99999999at'''''''''''''''
52766+ case 18446744073709549357LLU: // 99999999ar'''''''''''''''
5267452767 {
5267552768 {
5267652769 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -52690,7 +52783,7 @@
5269052783 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5269152784 }
5269252785 // ACCUMULATE ARGUMENTS - END
52693- uint64_t return_to = 18446744073709549360LLU;
52786+ uint64_t return_to = 18446744073709549358LLU;
5269452787 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5269552788 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5269652789 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52699,7 +52792,7 @@
5269952792 state.addr = 819859607768530944LLU; // resdest___
5270052793 break;
5270152794 }
52702- case 18446744073709549360LLU: // 99999999au'''''''''''''''
52795+ case 18446744073709549358LLU: // 99999999as'''''''''''''''
5270352796 {
5270452797 // ACCUMULATE ARGUMENTS - BEGIN
5270552798 {
@@ -52719,7 +52812,7 @@
5271952812 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5272052813 }
5272152814 // ACCUMULATE ARGUMENTS - END
52722- uint64_t return_to = 18446744073709549358LLU;
52815+ uint64_t return_to = 18446744073709549356LLU;
5272352816 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5272452817 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5272552818 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52728,7 +52821,7 @@
5272852821 state.addr = 819857494882385920LLU; // res_u64___
5272952822 break;
5273052823 }
52731- case 18446744073709549358LLU: // 99999999as'''''''''''''''
52824+ case 18446744073709549356LLU: // 99999999aq'''''''''''''''
5273252825 {
5273352826 // ACCUMULATE ARGUMENTS - BEGIN
5273452827 {
@@ -52736,7 +52829,7 @@
5273652829 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5273752830 }
5273852831 // ACCUMULATE ARGUMENTS - END
52739- uint64_t return_to = 18446744073709549357LLU;
52832+ uint64_t return_to = 18446744073709549355LLU;
5274052833 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5274152834 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5274252835 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52745,7 +52838,7 @@
5274552838 state.addr = 839519665163075584LLU; // skip______
5274652839 break;
5274752840 }
52748- case 18446744073709549357LLU: // 99999999ar'''''''''''''''
52841+ case 18446744073709549355LLU: // 99999999ap'''''''''''''''
5274952842 {
5275052843 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5275152844 fprintf(stdout, "%s", "\n ");
@@ -52771,7 +52864,7 @@
5277152864 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5277252865 }
5277352866 // ACCUMULATE ARGUMENTS - END
52774- uint64_t return_to = 18446744073709549356LLU;
52867+ uint64_t return_to = 18446744073709549354LLU;
5277552868 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5277652869 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5277752870 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52780,7 +52873,7 @@
5278052873 state.addr = 587881357514113024LLU; // emitpar___
5278152874 break;
5278252875 }
52783- case 18446744073709549356LLU: // 99999999aq'''''''''''''''
52876+ case 18446744073709549354LLU: // 99999999ao'''''''''''''''
5278452877 {
5278552878 fprintf(stdout, "%s", " = ");
5278652879 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52789,7 +52882,7 @@
5278952882 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5279052883 }
5279152884 // ACCUMULATE ARGUMENTS - END
52792- uint64_t return_to = 18446744073709549355LLU;
52885+ uint64_t return_to = 18446744073709549353LLU;
5279352886 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5279452887 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5279552888 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52798,7 +52891,7 @@
5279852891 state.addr = 839519665163075584LLU; // skip______
5279952892 break;
5280052893 }
52801- case 18446744073709549355LLU: // 99999999ap'''''''''''''''
52894+ case 18446744073709549353LLU: // 99999999an'''''''''''''''
5280252895 {
5280352896
5280452897 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52820,7 +52913,7 @@
5282052913 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5282152914 }
5282252915 // ACCUMULATE ARGUMENTS - END
52823- uint64_t return_to = 18446744073709549354LLU;
52916+ uint64_t return_to = 18446744073709549352LLU;
5282452917 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5282552918 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5282652919 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52829,7 +52922,7 @@
5282952922 state.addr = 23446349213393492LLU; // ASSERTINIT
5283052923 break;
5283152924 }
52832- case 18446744073709549354LLU: // 99999999ao'''''''''''''''
52925+ case 18446744073709549352LLU: // 99999999am'''''''''''''''
5283352926 {
5283452927 {
5283552928 uint64_t arg = 0;
@@ -52908,7 +53001,7 @@
5290853001 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5290953002 }
5291053003 // ACCUMULATE ARGUMENTS - END
52911- uint64_t return_to = 18446744073709549353LLU;
53004+ uint64_t return_to = 18446744073709549351LLU;
5291253005 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5291353006 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5291453007 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52917,7 +53010,7 @@
5291753010 state.addr = 293363126232490310LLU; // PROCVARREF
5291853011 break;
5291953012 }
52920- case 18446744073709549353LLU: // 99999999an'''''''''''''''
53013+ case 18446744073709549351LLU: // 99999999al'''''''''''''''
5292153014 {
5292253015 // variable u64 initialize goes out of scope
5292353016 // emitted destructur for type u64
@@ -52938,7 +53031,7 @@
5293853031 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5293953032 }
5294053033 // ACCUMULATE ARGUMENTS - END
52941- uint64_t return_to = 18446744073709549352LLU;
53034+ uint64_t return_to = 18446744073709549350LLU;
5294253035 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5294353036 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5294453037 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52947,7 +53040,7 @@
5294753040 state.addr = 517555565476695680LLU; // assertu64_
5294853041 break;
5294953042 }
52950- case 18446744073709549352LLU: // 99999999am'''''''''''''''
53043+ case 18446744073709549350LLU: // 99999999ak'''''''''''''''
5295153044 {
5295253045 // ACCUMULATE ARGUMENTS - BEGIN
5295353046 {
@@ -52955,7 +53048,7 @@
5295553048 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5295653049 }
5295753050 // ACCUMULATE ARGUMENTS - END
52958- uint64_t return_to = 18446744073709549351LLU;
53051+ uint64_t return_to = 18446744073709549349LLU;
5295953052 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5296053053 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5296153054 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52964,7 +53057,7 @@
5296453057 state.addr = 839519665163075584LLU; // skip______
5296553058 break;
5296653059 }
52967- case 18446744073709549351LLU: // 99999999al'''''''''''''''
53060+ case 18446744073709549349LLU: // 99999999aj'''''''''''''''
5296853061 {
5296953062 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5297053063 fprintf(stdout, "%s", " - ");
@@ -52974,7 +53067,7 @@
5297453067 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5297553068 }
5297653069 // ACCUMULATE ARGUMENTS - END
52977- uint64_t return_to = 18446744073709549350LLU;
53070+ uint64_t return_to = 18446744073709549348LLU;
5297853071 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5297953072 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5298053073 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52983,7 +53076,7 @@
5298353076 state.addr = 839519665163075584LLU; // skip______
5298453077 break;
5298553078 }
52986- case 18446744073709549350LLU: // 99999999ak'''''''''''''''
53079+ case 18446744073709549348LLU: // 99999999ai'''''''''''''''
5298753080 {
5298853081
5298953082 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -53005,7 +53098,7 @@
5300553098 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5300653099 }
5300753100 // ACCUMULATE ARGUMENTS - END
53008- uint64_t return_to = 18446744073709549349LLU;
53101+ uint64_t return_to = 18446744073709549347LLU;
5300953102 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5301053103 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5301153104 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53014,7 +53107,7 @@
5301453107 state.addr = 23446349213393492LLU; // ASSERTINIT
5301553108 break;
5301653109 }
53017- case 18446744073709549349LLU: // 99999999aj'''''''''''''''
53110+ case 18446744073709549347LLU: // 99999999ah'''''''''''''''
5301853111 {
5301953112 {
5302053113 uint64_t arg = 0;
@@ -53093,7 +53186,7 @@
5309353186 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5309453187 }
5309553188 // ACCUMULATE ARGUMENTS - END
53096- uint64_t return_to = 18446744073709549348LLU;
53189+ uint64_t return_to = 18446744073709549346LLU;
5309753190 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5309853191 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5309953192 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53102,7 +53195,7 @@
5310253195 state.addr = 293363126232490310LLU; // PROCVARREF
5310353196 break;
5310453197 }
53105- case 18446744073709549348LLU: // 99999999ai'''''''''''''''
53198+ case 18446744073709549346LLU: // 99999999ag'''''''''''''''
5310653199 {
5310753200 // variable u64 initialize goes out of scope
5310853201 // emitted destructur for type u64
@@ -53123,7 +53216,7 @@
5312353216 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5312453217 }
5312553218 // ACCUMULATE ARGUMENTS - END
53126- uint64_t return_to = 18446744073709549347LLU;
53219+ uint64_t return_to = 18446744073709549345LLU;
5312753220 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5312853221 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5312953222 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53132,7 +53225,7 @@
5313253225 state.addr = 517555565476695680LLU; // assertu64_
5313353226 break;
5313453227 }
53135- case 18446744073709549347LLU: // 99999999ah'''''''''''''''
53228+ case 18446744073709549345LLU: // 99999999af'''''''''''''''
5313653229 {
5313753230 // ACCUMULATE ARGUMENTS - BEGIN
5313853231 {
@@ -53140,7 +53233,7 @@
5314053233 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5314153234 }
5314253235 // ACCUMULATE ARGUMENTS - END
53143- uint64_t return_to = 18446744073709549346LLU;
53236+ uint64_t return_to = 18446744073709549344LLU;
5314453237 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5314553238 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5314653239 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53149,7 +53242,7 @@
5314953242 state.addr = 839519665163075584LLU; // skip______
5315053243 break;
5315153244 }
53152- case 18446744073709549346LLU: // 99999999ag'''''''''''''''
53245+ case 18446744073709549344LLU: // 99999999ae'''''''''''''''
5315353246 {
5315453247 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5315553248 fprintf(stdout, "%s", ";");
@@ -53161,7 +53254,7 @@
5316153254 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5316253255 }
5316353256 // ACCUMULATE ARGUMENTS - END
53164- uint64_t return_to = 18446744073709549345LLU;
53257+ uint64_t return_to = 18446744073709549343LLU;
5316553258 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5316653259 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5316753260 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53170,7 +53263,7 @@
5317053263 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5317153264 break;
5317253265 }
53173- case 18446744073709549345LLU: // 99999999af'''''''''''''''
53266+ case 18446744073709549343LLU: // 99999999ad'''''''''''''''
5317453267 {
5317553268 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5317653269 // variable type______ type______ goes out of scope
@@ -53181,7 +53274,7 @@
5318153274 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5318253275 }
5318353276 // ACCUMULATE ARGUMENTS - END
53184- uint64_t return_to = 18446744073709549344LLU;
53277+ uint64_t return_to = 18446744073709549342LLU;
5318553278 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5318653279 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5318753280 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53190,7 +53283,7 @@
5319053283 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5319153284 break;
5319253285 }
53193- case 18446744073709549344LLU: // 99999999ae'''''''''''''''
53286+ case 18446744073709549342LLU: // 99999999ac'''''''''''''''
5319453287 {
5319553288 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5319653289 // variable u64 mutable___ goes out of scope
@@ -53202,10 +53295,10 @@
5320253295 // variable u64 id________ goes out of scope
5320353296 // emitted destructur for type u64
5320453297 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
53205- state.addr = 18446744073709549362LLU; // 99999999aw'''''''''''''''
53298+ state.addr = 18446744073709549360LLU; // 99999999au'''''''''''''''
5320653299 break;
5320753300 }
53208- case 18446744073709549363LLU: // 99999999ax'''''''''''''''
53301+ case 18446744073709549361LLU: // 99999999av'''''''''''''''
5320953302 {
5321053303
5321153304 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 734258263075323904;
@@ -53216,11 +53309,11 @@
5321653309 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5321753310 }
5321853311 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53219- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549343LLU : 18446744073709549342LLU;
53312+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549341LLU : 18446744073709549340LLU;
5322053313 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5322153314 break;
5322253315 }
53223- case 18446744073709549343LLU: // 99999999ad'''''''''''''''
53316+ case 18446744073709549341LLU: // 99999999ab'''''''''''''''
5322453317 {
5322553318 {
5322653319 uint64_t arg = 0;
@@ -53247,7 +53340,7 @@
5324753340 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5324853341 }
5324953342 // ACCUMULATE ARGUMENTS - END
53250- uint64_t return_to = 18446744073709549340LLU;
53343+ uint64_t return_to = 18446744073709549338LLU;
5325153344 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5325253345 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5325353346 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53256,7 +53349,7 @@
5325653349 state.addr = 861504796319285248LLU; // typeu64___
5325753350 break;
5325853351 }
53259- case 18446744073709549340LLU: // 99999999aa'''''''''''''''
53352+ case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
5326053353 {
5326153354 {
5326253355 uint64_t arg = 0;
@@ -53281,7 +53374,7 @@
5328153374 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5328253375 }
5328353376 // ACCUMULATE ARGUMENTS - END
53284- uint64_t return_to = 18446744073709549338LLU;
53377+ uint64_t return_to = 18446744073709549336LLU;
5328553378 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5328653379 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5328753380 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53290,7 +53383,7 @@
5329053383 state.addr = 861504796319285248LLU; // typeu64___
5329153384 break;
5329253385 }
53293- case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
53386+ case 18446744073709549336LLU: // 99999999aX'''''''''''''''
5329453387 {
5329553388 {
5329653389 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -53310,7 +53403,7 @@
5331053403 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5331153404 }
5331253405 // ACCUMULATE ARGUMENTS - END
53313- uint64_t return_to = 18446744073709549339LLU;
53406+ uint64_t return_to = 18446744073709549337LLU;
5331453407 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5331553408 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5331653409 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53319,7 +53412,7 @@
5331953412 state.addr = 819859607768530944LLU; // resdest___
5332053413 break;
5332153414 }
53322- case 18446744073709549339LLU: // 99999999a$'''''''''''''''
53415+ case 18446744073709549337LLU: // 99999999aY'''''''''''''''
5332353416 {
5332453417 // ACCUMULATE ARGUMENTS - BEGIN
5332553418 {
@@ -53339,7 +53432,7 @@
5333953432 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5334053433 }
5334153434 // ACCUMULATE ARGUMENTS - END
53342- uint64_t return_to = 18446744073709549337LLU;
53435+ uint64_t return_to = 18446744073709549335LLU;
5334353436 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5334453437 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5334553438 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53348,7 +53441,7 @@
5334853441 state.addr = 819857494882385920LLU; // res_u64___
5334953442 break;
5335053443 }
53351- case 18446744073709549337LLU: // 99999999aY'''''''''''''''
53444+ case 18446744073709549335LLU: // 99999999aW'''''''''''''''
5335253445 {
5335353446 // ACCUMULATE ARGUMENTS - BEGIN
5335453447 {
@@ -53356,7 +53449,7 @@
5335653449 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5335753450 }
5335853451 // ACCUMULATE ARGUMENTS - END
53359- uint64_t return_to = 18446744073709549336LLU;
53452+ uint64_t return_to = 18446744073709549334LLU;
5336053453 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5336153454 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5336253455 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53365,7 +53458,7 @@
5336553458 state.addr = 839519665163075584LLU; // skip______
5336653459 break;
5336753460 }
53368- case 18446744073709549336LLU: // 99999999aX'''''''''''''''
53461+ case 18446744073709549334LLU: // 99999999aV'''''''''''''''
5336953462 {
5337053463 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5337153464 fprintf(stdout, "%s", "\n ");
@@ -53391,7 +53484,7 @@
5339153484 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5339253485 }
5339353486 // ACCUMULATE ARGUMENTS - END
53394- uint64_t return_to = 18446744073709549335LLU;
53487+ uint64_t return_to = 18446744073709549333LLU;
5339553488 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5339653489 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5339753490 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53400,7 +53493,7 @@
5340053493 state.addr = 587881357514113024LLU; // emitpar___
5340153494 break;
5340253495 }
53403- case 18446744073709549335LLU: // 99999999aW'''''''''''''''
53496+ case 18446744073709549333LLU: // 99999999aU'''''''''''''''
5340453497 {
5340553498 fprintf(stdout, "%s", " = ");
5340653499 // ACCUMULATE ARGUMENTS - BEGIN
@@ -53409,7 +53502,7 @@
5340953502 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5341053503 }
5341153504 // ACCUMULATE ARGUMENTS - END
53412- uint64_t return_to = 18446744073709549334LLU;
53505+ uint64_t return_to = 18446744073709549332LLU;
5341353506 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5341453507 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5341553508 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53418,7 +53511,7 @@
5341853511 state.addr = 839519665163075584LLU; // skip______
5341953512 break;
5342053513 }
53421- case 18446744073709549334LLU: // 99999999aV'''''''''''''''
53514+ case 18446744073709549332LLU: // 99999999aT'''''''''''''''
5342253515 {
5342353516
5342453517 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -53440,7 +53533,7 @@
5344053533 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5344153534 }
5344253535 // ACCUMULATE ARGUMENTS - END
53443- uint64_t return_to = 18446744073709549333LLU;
53536+ uint64_t return_to = 18446744073709549331LLU;
5344453537 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5344553538 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5344653539 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53449,7 +53542,7 @@
5344953542 state.addr = 23446349213393492LLU; // ASSERTINIT
5345053543 break;
5345153544 }
53452- case 18446744073709549333LLU: // 99999999aU'''''''''''''''
53545+ case 18446744073709549331LLU: // 99999999aS'''''''''''''''
5345353546 {
5345453547 {
5345553548 uint64_t arg = 0;
@@ -53528,7 +53621,7 @@
5352853621 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5352953622 }
5353053623 // ACCUMULATE ARGUMENTS - END
53531- uint64_t return_to = 18446744073709549332LLU;
53624+ uint64_t return_to = 18446744073709549330LLU;
5353253625 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5353353626 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5353453627 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53537,7 +53630,7 @@
5353753630 state.addr = 293363126232490310LLU; // PROCVARREF
5353853631 break;
5353953632 }
53540- case 18446744073709549332LLU: // 99999999aT'''''''''''''''
53633+ case 18446744073709549330LLU: // 99999999aR'''''''''''''''
5354153634 {
5354253635 // variable u64 initialize goes out of scope
5354353636 // emitted destructur for type u64
@@ -53558,7 +53651,7 @@
5355853651 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5355953652 }
5356053653 // ACCUMULATE ARGUMENTS - END
53561- uint64_t return_to = 18446744073709549331LLU;
53654+ uint64_t return_to = 18446744073709549329LLU;
5356253655 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5356353656 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5356453657 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53567,7 +53660,7 @@
5356753660 state.addr = 517555565476695680LLU; // assertu64_
5356853661 break;
5356953662 }
53570- case 18446744073709549331LLU: // 99999999aS'''''''''''''''
53663+ case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
5357153664 {
5357253665 // ACCUMULATE ARGUMENTS - BEGIN
5357353666 {
@@ -53575,7 +53668,7 @@
5357553668 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5357653669 }
5357753670 // ACCUMULATE ARGUMENTS - END
53578- uint64_t return_to = 18446744073709549330LLU;
53671+ uint64_t return_to = 18446744073709549328LLU;
5357953672 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5358053673 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5358153674 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53584,7 +53677,7 @@
5358453677 state.addr = 839519665163075584LLU; // skip______
5358553678 break;
5358653679 }
53587- case 18446744073709549330LLU: // 99999999aR'''''''''''''''
53680+ case 18446744073709549328LLU: // 99999999aP'''''''''''''''
5358853681 {
5358953682 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5359053683 fprintf(stdout, "%s", " * ");
@@ -53594,7 +53687,7 @@
5359453687 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5359553688 }
5359653689 // ACCUMULATE ARGUMENTS - END
53597- uint64_t return_to = 18446744073709549329LLU;
53690+ uint64_t return_to = 18446744073709549327LLU;
5359853691 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5359953692 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5360053693 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53603,7 +53696,7 @@
5360353696 state.addr = 839519665163075584LLU; // skip______
5360453697 break;
5360553698 }
53606- case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
53699+ case 18446744073709549327LLU: // 99999999aO'''''''''''''''
5360753700 {
5360853701
5360953702 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -53625,7 +53718,7 @@
5362553718 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5362653719 }
5362753720 // ACCUMULATE ARGUMENTS - END
53628- uint64_t return_to = 18446744073709549328LLU;
53721+ uint64_t return_to = 18446744073709549326LLU;
5362953722 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5363053723 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5363153724 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53634,7 +53727,7 @@
5363453727 state.addr = 23446349213393492LLU; // ASSERTINIT
5363553728 break;
5363653729 }
53637- case 18446744073709549328LLU: // 99999999aP'''''''''''''''
53730+ case 18446744073709549326LLU: // 99999999aN'''''''''''''''
5363853731 {
5363953732 {
5364053733 uint64_t arg = 0;
@@ -53713,7 +53806,7 @@
5371353806 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5371453807 }
5371553808 // ACCUMULATE ARGUMENTS - END
53716- uint64_t return_to = 18446744073709549327LLU;
53809+ uint64_t return_to = 18446744073709549325LLU;
5371753810 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5371853811 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5371953812 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53722,7 +53815,7 @@
5372253815 state.addr = 293363126232490310LLU; // PROCVARREF
5372353816 break;
5372453817 }
53725- case 18446744073709549327LLU: // 99999999aO'''''''''''''''
53818+ case 18446744073709549325LLU: // 99999999aM'''''''''''''''
5372653819 {
5372753820 // variable u64 initialize goes out of scope
5372853821 // emitted destructur for type u64
@@ -53743,7 +53836,7 @@
5374353836 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5374453837 }
5374553838 // ACCUMULATE ARGUMENTS - END
53746- uint64_t return_to = 18446744073709549326LLU;
53839+ uint64_t return_to = 18446744073709549324LLU;
5374753840 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5374853841 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5374953842 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53752,7 +53845,7 @@
5375253845 state.addr = 517555565476695680LLU; // assertu64_
5375353846 break;
5375453847 }
53755- case 18446744073709549326LLU: // 99999999aN'''''''''''''''
53848+ case 18446744073709549324LLU: // 99999999aL'''''''''''''''
5375653849 {
5375753850 // ACCUMULATE ARGUMENTS - BEGIN
5375853851 {
@@ -53760,7 +53853,7 @@
5376053853 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5376153854 }
5376253855 // ACCUMULATE ARGUMENTS - END
53763- uint64_t return_to = 18446744073709549325LLU;
53856+ uint64_t return_to = 18446744073709549323LLU;
5376453857 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5376553858 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5376653859 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53769,7 +53862,7 @@
5376953862 state.addr = 839519665163075584LLU; // skip______
5377053863 break;
5377153864 }
53772- case 18446744073709549325LLU: // 99999999aM'''''''''''''''
53865+ case 18446744073709549323LLU: // 99999999aK'''''''''''''''
5377353866 {
5377453867 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5377553868 fprintf(stdout, "%s", ";");
@@ -53781,7 +53874,7 @@
5378153874 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5378253875 }
5378353876 // ACCUMULATE ARGUMENTS - END
53784- uint64_t return_to = 18446744073709549324LLU;
53877+ uint64_t return_to = 18446744073709549322LLU;
5378553878 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5378653879 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5378753880 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53790,7 +53883,7 @@
5379053883 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5379153884 break;
5379253885 }
53793- case 18446744073709549324LLU: // 99999999aL'''''''''''''''
53886+ case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
5379453887 {
5379553888 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5379653889 // variable type______ type______ goes out of scope
@@ -53801,7 +53894,7 @@
5380153894 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5380253895 }
5380353896 // ACCUMULATE ARGUMENTS - END
53804- uint64_t return_to = 18446744073709549323LLU;
53897+ uint64_t return_to = 18446744073709549321LLU;
5380553898 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5380653899 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5380753900 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53810,7 +53903,7 @@
5381053903 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5381153904 break;
5381253905 }
53813- case 18446744073709549323LLU: // 99999999aK'''''''''''''''
53906+ case 18446744073709549321LLU: // 99999999aI'''''''''''''''
5381453907 {
5381553908 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5381653909 // variable u64 mutable___ goes out of scope
@@ -53822,10 +53915,10 @@
5382253915 // variable u64 id________ goes out of scope
5382353916 // emitted destructur for type u64
5382453917 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
53825- state.addr = 18446744073709549341LLU; // 99999999ab'''''''''''''''
53918+ state.addr = 18446744073709549339LLU; // 99999999a$'''''''''''''''
5382653919 break;
5382753920 }
53828- case 18446744073709549342LLU: // 99999999ac'''''''''''''''
53921+ case 18446744073709549340LLU: // 99999999aa'''''''''''''''
5382953922 {
5383053923
5383153924 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 568794957234569216;
@@ -53836,11 +53929,11 @@
5383653929 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5383753930 }
5383853931 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53839- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549322LLU : 18446744073709549321LLU;
53932+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549320LLU : 18446744073709549319LLU;
5384053933 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5384153934 break;
5384253935 }
53843- case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
53936+ case 18446744073709549320LLU: // 99999999aH'''''''''''''''
5384453937 {
5384553938 {
5384653939 uint64_t arg = 0;
@@ -53867,7 +53960,7 @@
5386753960 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5386853961 }
5386953962 // ACCUMULATE ARGUMENTS - END
53870- uint64_t return_to = 18446744073709549319LLU;
53963+ uint64_t return_to = 18446744073709549317LLU;
5387153964 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5387253965 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5387353966 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53876,7 +53969,7 @@
5387653969 state.addr = 861504796319285248LLU; // typeu64___
5387753970 break;
5387853971 }
53879- case 18446744073709549319LLU: // 99999999aG'''''''''''''''
53972+ case 18446744073709549317LLU: // 99999999aE'''''''''''''''
5388053973 {
5388153974 {
5388253975 uint64_t arg = 0;
@@ -53901,7 +53994,7 @@
5390153994 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5390253995 }
5390353996 // ACCUMULATE ARGUMENTS - END
53904- uint64_t return_to = 18446744073709549317LLU;
53997+ uint64_t return_to = 18446744073709549315LLU;
5390553998 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5390653999 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5390754000 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53910,7 +54003,7 @@
5391054003 state.addr = 861504796319285248LLU; // typeu64___
5391154004 break;
5391254005 }
53913- case 18446744073709549317LLU: // 99999999aE'''''''''''''''
54006+ case 18446744073709549315LLU: // 99999999aC'''''''''''''''
5391454007 {
5391554008 {
5391654009 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -53930,7 +54023,7 @@
5393054023 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5393154024 }
5393254025 // ACCUMULATE ARGUMENTS - END
53933- uint64_t return_to = 18446744073709549318LLU;
54026+ uint64_t return_to = 18446744073709549316LLU;
5393454027 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5393554028 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5393654029 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53939,7 +54032,7 @@
5393954032 state.addr = 819859607768530944LLU; // resdest___
5394054033 break;
5394154034 }
53942- case 18446744073709549318LLU: // 99999999aF'''''''''''''''
54035+ case 18446744073709549316LLU: // 99999999aD'''''''''''''''
5394354036 {
5394454037 // ACCUMULATE ARGUMENTS - BEGIN
5394554038 {
@@ -53959,7 +54052,7 @@
5395954052 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5396054053 }
5396154054 // ACCUMULATE ARGUMENTS - END
53962- uint64_t return_to = 18446744073709549316LLU;
54055+ uint64_t return_to = 18446744073709549314LLU;
5396354056 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5396454057 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5396554058 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53968,7 +54061,7 @@
5396854061 state.addr = 819857494882385920LLU; // res_u64___
5396954062 break;
5397054063 }
53971- case 18446744073709549316LLU: // 99999999aD'''''''''''''''
54064+ case 18446744073709549314LLU: // 99999999aB'''''''''''''''
5397254065 {
5397354066 // ACCUMULATE ARGUMENTS - BEGIN
5397454067 {
@@ -53976,7 +54069,7 @@
5397654069 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5397754070 }
5397854071 // ACCUMULATE ARGUMENTS - END
53979- uint64_t return_to = 18446744073709549315LLU;
54072+ uint64_t return_to = 18446744073709549313LLU;
5398054073 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5398154074 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5398254075 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53985,7 +54078,7 @@
5398554078 state.addr = 839519665163075584LLU; // skip______
5398654079 break;
5398754080 }
53988- case 18446744073709549315LLU: // 99999999aC'''''''''''''''
54081+ case 18446744073709549313LLU: // 99999999aA'''''''''''''''
5398954082 {
5399054083 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5399154084 fprintf(stdout, "%s", "\n ");
@@ -54011,7 +54104,7 @@
5401154104 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5401254105 }
5401354106 // ACCUMULATE ARGUMENTS - END
54014- uint64_t return_to = 18446744073709549314LLU;
54107+ uint64_t return_to = 18446744073709549312LLU;
5401554108 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5401654109 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5401754110 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54020,7 +54113,7 @@
5402054113 state.addr = 587881357514113024LLU; // emitpar___
5402154114 break;
5402254115 }
54023- case 18446744073709549314LLU: // 99999999aB'''''''''''''''
54116+ case 18446744073709549312LLU: // 99999999a_'''''''''''''''
5402454117 {
5402554118 fprintf(stdout, "%s", " = ");
5402654119 // ACCUMULATE ARGUMENTS - BEGIN
@@ -54029,7 +54122,7 @@
5402954122 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5403054123 }
5403154124 // ACCUMULATE ARGUMENTS - END
54032- uint64_t return_to = 18446744073709549313LLU;
54125+ uint64_t return_to = 18446744073709549311LLU;
5403354126 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5403454127 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5403554128 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54038,7 +54131,7 @@
5403854131 state.addr = 839519665163075584LLU; // skip______
5403954132 break;
5404054133 }
54041- case 18446744073709549313LLU: // 99999999aA'''''''''''''''
54134+ case 18446744073709549311LLU: // 99999999$9'''''''''''''''
5404254135 {
5404354136
5404454137 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -54060,7 +54153,7 @@
5406054153 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5406154154 }
5406254155 // ACCUMULATE ARGUMENTS - END
54063- uint64_t return_to = 18446744073709549312LLU;
54156+ uint64_t return_to = 18446744073709549310LLU;
5406454157 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5406554158 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5406654159 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54069,7 +54162,7 @@
5406954162 state.addr = 23446349213393492LLU; // ASSERTINIT
5407054163 break;
5407154164 }
54072- case 18446744073709549312LLU: // 99999999a_'''''''''''''''
54165+ case 18446744073709549310LLU: // 99999999$8'''''''''''''''
5407354166 {
5407454167 {
5407554168 uint64_t arg = 0;
@@ -54148,7 +54241,7 @@
5414854241 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5414954242 }
5415054243 // ACCUMULATE ARGUMENTS - END
54151- uint64_t return_to = 18446744073709549311LLU;
54244+ uint64_t return_to = 18446744073709549309LLU;
5415254245 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5415354246 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5415454247 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54157,7 +54250,7 @@
5415754250 state.addr = 293363126232490310LLU; // PROCVARREF
5415854251 break;
5415954252 }
54160- case 18446744073709549311LLU: // 99999999$9'''''''''''''''
54253+ case 18446744073709549309LLU: // 99999999$7'''''''''''''''
5416154254 {
5416254255 // variable u64 initialize goes out of scope
5416354256 // emitted destructur for type u64
@@ -54178,7 +54271,7 @@
5417854271 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5417954272 }
5418054273 // ACCUMULATE ARGUMENTS - END
54181- uint64_t return_to = 18446744073709549310LLU;
54274+ uint64_t return_to = 18446744073709549308LLU;
5418254275 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5418354276 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5418454277 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54187,7 +54280,7 @@
5418754280 state.addr = 517555565476695680LLU; // assertu64_
5418854281 break;
5418954282 }
54190- case 18446744073709549310LLU: // 99999999$8'''''''''''''''
54283+ case 18446744073709549308LLU: // 99999999$6'''''''''''''''
5419154284 {
5419254285 // ACCUMULATE ARGUMENTS - BEGIN
5419354286 {
@@ -54195,7 +54288,7 @@
5419554288 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5419654289 }
5419754290 // ACCUMULATE ARGUMENTS - END
54198- uint64_t return_to = 18446744073709549309LLU;
54291+ uint64_t return_to = 18446744073709549307LLU;
5419954292 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5420054293 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5420154294 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54204,7 +54297,7 @@
5420454297 state.addr = 839519665163075584LLU; // skip______
5420554298 break;
5420654299 }
54207- case 18446744073709549309LLU: // 99999999$7'''''''''''''''
54300+ case 18446744073709549307LLU: // 99999999$5'''''''''''''''
5420854301 {
5420954302 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5421054303 fprintf(stdout, "%s", " / ");
@@ -54214,7 +54307,7 @@
5421454307 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5421554308 }
5421654309 // ACCUMULATE ARGUMENTS - END
54217- uint64_t return_to = 18446744073709549308LLU;
54310+ uint64_t return_to = 18446744073709549306LLU;
5421854311 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5421954312 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5422054313 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54223,7 +54316,7 @@
5422354316 state.addr = 839519665163075584LLU; // skip______
5422454317 break;
5422554318 }
54226- case 18446744073709549308LLU: // 99999999$6'''''''''''''''
54319+ case 18446744073709549306LLU: // 99999999$4'''''''''''''''
5422754320 {
5422854321
5422954322 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -54245,7 +54338,7 @@
5424554338 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5424654339 }
5424754340 // ACCUMULATE ARGUMENTS - END
54248- uint64_t return_to = 18446744073709549307LLU;
54341+ uint64_t return_to = 18446744073709549305LLU;
5424954342 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5425054343 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5425154344 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54254,7 +54347,7 @@
5425454347 state.addr = 23446349213393492LLU; // ASSERTINIT
5425554348 break;
5425654349 }
54257- case 18446744073709549307LLU: // 99999999$5'''''''''''''''
54350+ case 18446744073709549305LLU: // 99999999$3'''''''''''''''
5425854351 {
5425954352 {
5426054353 uint64_t arg = 0;
@@ -54333,7 +54426,7 @@
5433354426 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5433454427 }
5433554428 // ACCUMULATE ARGUMENTS - END
54336- uint64_t return_to = 18446744073709549306LLU;
54429+ uint64_t return_to = 18446744073709549304LLU;
5433754430 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5433854431 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5433954432 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54342,7 +54435,7 @@
5434254435 state.addr = 293363126232490310LLU; // PROCVARREF
5434354436 break;
5434454437 }
54345- case 18446744073709549306LLU: // 99999999$4'''''''''''''''
54438+ case 18446744073709549304LLU: // 99999999$2'''''''''''''''
5434654439 {
5434754440 // variable u64 initialize goes out of scope
5434854441 // emitted destructur for type u64
@@ -54363,7 +54456,7 @@
5436354456 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5436454457 }
5436554458 // ACCUMULATE ARGUMENTS - END
54366- uint64_t return_to = 18446744073709549305LLU;
54459+ uint64_t return_to = 18446744073709549303LLU;
5436754460 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5436854461 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5436954462 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54372,7 +54465,7 @@
5437254465 state.addr = 517555565476695680LLU; // assertu64_
5437354466 break;
5437454467 }
54375- case 18446744073709549305LLU: // 99999999$3'''''''''''''''
54468+ case 18446744073709549303LLU: // 99999999$1'''''''''''''''
5437654469 {
5437754470 // ACCUMULATE ARGUMENTS - BEGIN
5437854471 {
@@ -54380,7 +54473,7 @@
5438054473 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5438154474 }
5438254475 // ACCUMULATE ARGUMENTS - END
54383- uint64_t return_to = 18446744073709549304LLU;
54476+ uint64_t return_to = 18446744073709549302LLU;
5438454477 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5438554478 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5438654479 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54389,7 +54482,7 @@
5438954482 state.addr = 839519665163075584LLU; // skip______
5439054483 break;
5439154484 }
54392- case 18446744073709549304LLU: // 99999999$2'''''''''''''''
54485+ case 18446744073709549302LLU: // 99999999$0'''''''''''''''
5439354486 {
5439454487 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5439554488 fprintf(stdout, "%s", ";");
@@ -54401,7 +54494,7 @@
5440154494 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5440254495 }
5440354496 // ACCUMULATE ARGUMENTS - END
54404- uint64_t return_to = 18446744073709549303LLU;
54497+ uint64_t return_to = 18446744073709549301LLU;
5440554498 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5440654499 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5440754500 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54410,7 +54503,7 @@
5441054503 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5441154504 break;
5441254505 }
54413- case 18446744073709549303LLU: // 99999999$1'''''''''''''''
54506+ case 18446744073709549301LLU: // 99999999$z'''''''''''''''
5441454507 {
5441554508 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5441654509 // variable type______ type______ goes out of scope
@@ -54421,7 +54514,7 @@
5442154514 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5442254515 }
5442354516 // ACCUMULATE ARGUMENTS - END
54424- uint64_t return_to = 18446744073709549302LLU;
54517+ uint64_t return_to = 18446744073709549300LLU;
5442554518 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5442654519 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5442754520 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54430,7 +54523,7 @@
5443054523 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5443154524 break;
5443254525 }
54433- case 18446744073709549302LLU: // 99999999$0'''''''''''''''
54526+ case 18446744073709549300LLU: // 99999999$y'''''''''''''''
5443454527 {
5443554528 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5443654529 // variable u64 mutable___ goes out of scope
@@ -54442,10 +54535,10 @@
5444254535 // variable u64 id________ goes out of scope
5444354536 // emitted destructur for type u64
5444454537 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
54445- state.addr = 18446744073709549320LLU; // 99999999aH'''''''''''''''
54538+ state.addr = 18446744073709549318LLU; // 99999999aF'''''''''''''''
5444654539 break;
5444754540 }
54448- case 18446744073709549321LLU: // 99999999aI'''''''''''''''
54541+ case 18446744073709549319LLU: // 99999999aG'''''''''''''''
5444954542 {
5445054543
5445154544 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 732534228842971136;
@@ -54456,11 +54549,11 @@
5445654549 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5445754550 }
5445854551 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
54459- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549301LLU : 18446744073709549300LLU;
54552+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549299LLU : 18446744073709549298LLU;
5446054553 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5446154554 break;
5446254555 }
54463- case 18446744073709549301LLU: // 99999999$z'''''''''''''''
54556+ case 18446744073709549299LLU: // 99999999$x'''''''''''''''
5446454557 {
5446554558 {
5446654559 uint64_t arg = 0;
@@ -54487,7 +54580,7 @@
5448754580 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5448854581 }
5448954582 // ACCUMULATE ARGUMENTS - END
54490- uint64_t return_to = 18446744073709549298LLU;
54583+ uint64_t return_to = 18446744073709549296LLU;
5449154584 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5449254585 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5449354586 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54496,7 +54589,7 @@
5449654589 state.addr = 861504796319285248LLU; // typeu64___
5449754590 break;
5449854591 }
54499- case 18446744073709549298LLU: // 99999999$w'''''''''''''''
54592+ case 18446744073709549296LLU: // 99999999$u'''''''''''''''
5450054593 {
5450154594 {
5450254595 uint64_t arg = 0;
@@ -54521,7 +54614,7 @@
5452154614 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5452254615 }
5452354616 // ACCUMULATE ARGUMENTS - END
54524- uint64_t return_to = 18446744073709549296LLU;
54617+ uint64_t return_to = 18446744073709549294LLU;
5452554618 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5452654619 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5452754620 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54530,7 +54623,7 @@
5453054623 state.addr = 861504796319285248LLU; // typeu64___
5453154624 break;
5453254625 }
54533- case 18446744073709549296LLU: // 99999999$u'''''''''''''''
54626+ case 18446744073709549294LLU: // 99999999$s'''''''''''''''
5453454627 {
5453554628 {
5453654629 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -54550,7 +54643,7 @@
5455054643 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5455154644 }
5455254645 // ACCUMULATE ARGUMENTS - END
54553- uint64_t return_to = 18446744073709549297LLU;
54646+ uint64_t return_to = 18446744073709549295LLU;
5455454647 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5455554648 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5455654649 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54559,7 +54652,7 @@
5455954652 state.addr = 819859607768530944LLU; // resdest___
5456054653 break;
5456154654 }
54562- case 18446744073709549297LLU: // 99999999$v'''''''''''''''
54655+ case 18446744073709549295LLU: // 99999999$t'''''''''''''''
5456354656 {
5456454657 // ACCUMULATE ARGUMENTS - BEGIN
5456554658 {