• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision995 (tree)
Time2020-04-30 06:11:41
Authorjakobthomsen

Log Message

cleanup

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (revision 994)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (revision 995)
@@ -43669,575 +43669,6 @@
4366943669 }
4367043670 break;
4367143671 }
43672- case 293363123147526144LLU: // PROCSIZE__
43673- {
43674- {
43675- uint64_t arg = 0;
43676- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43677- }
43678- *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 0;
43679- // ACCUMULATE ARGUMENTS - BEGIN
43680- {
43681- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
43682- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43683- }
43684- // ACCUMULATE ARGUMENTS - END
43685- uint64_t return_to = 18446744073709549678LLU;
43686- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43687- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43688- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43689- heap.data[0].elem1 = heap.data[0].elem0;
43690- heap.data[0].elem0 = restore;
43691- state.addr = 839519665163075584LLU; // skip______
43692- break;
43693- }
43694- case 18446744073709549678LLU: // 99999999fs'''''''''''''''
43695- {
43696- matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)));
43697- fprintf(stdout, "%s", "\n list_size(heap.data, ");
43698- // ACCUMULATE ARGUMENTS - BEGIN
43699- {
43700- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
43701- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43702- }
43703- // ACCUMULATE ARGUMENTS - END
43704- uint64_t return_to = 18446744073709549677LLU;
43705- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43706- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43707- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43708- heap.data[0].elem1 = heap.data[0].elem0;
43709- heap.data[0].elem0 = restore;
43710- state.addr = 839519665163075584LLU; // skip______
43711- break;
43712- }
43713- case 18446744073709549677LLU: // 99999999fr'''''''''''''''
43714- {
43715- {
43716- uint64_t arg = 0;
43717- LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43718- }
43719- *LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = 0;
43720- {
43721- uint64_t arg = 0;
43722- LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43723- }
43724- // ACCUMULATE ARGUMENTS - BEGIN
43725- {
43726- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 12LLU, 11LLU);
43727- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43728- }
43729- // ACCUMULATE ARGUMENTS - END
43730- uint64_t return_to = 18446744073709549676LLU;
43731- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43732- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43733- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43734- heap.data[0].elem1 = heap.data[0].elem0;
43735- heap.data[0].elem0 = restore;
43736- state.addr = 861504796319285248LLU; // typeu64___
43737- break;
43738- }
43739- case 18446744073709549676LLU: // 99999999fq'''''''''''''''
43740- {
43741- {
43742- uint64_t arg = 0;
43743- LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43744- }
43745- *LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = 0;
43746- // ACCUMULATE ARGUMENTS - BEGIN
43747- {
43748- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 13LLU, 5LLU);
43749- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43750- }
43751- // ACCUMULATE ARGUMENTS - END
43752- uint64_t return_to = 18446744073709549675LLU;
43753- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43754- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43755- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43756- heap.data[0].elem1 = heap.data[0].elem0;
43757- heap.data[0].elem0 = restore;
43758- state.addr = 839519665163075584LLU; // skip______
43759- break;
43760- }
43761- case 18446744073709549675LLU: // 99999999fp'''''''''''''''
43762- {
43763-
43764- *LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
43765- {
43766- uint64_t arg = 0;
43767- LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43768- }
43769- *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = 0;
43770- {
43771- uint64_t arg = 0;
43772- LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43773- }
43774- *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0;
43775- {
43776- uint64_t arg = 0;
43777- LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43778- }
43779- *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 0;
43780- // ACCUMULATE ARGUMENTS - BEGIN
43781- {
43782- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 16LLU, 3LLU);
43783- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43784- }
43785- {
43786- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 16LLU, 0LLU);
43787- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43788- }
43789- {
43790- uint64_t arg = /*scopelist_*/*LOCAL_ACCESS(heap.data, 16LLU, 1LLU);
43791- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43792- }
43793- {
43794- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 16LLU, 2LLU);
43795- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43796- }
43797- {
43798- uint64_t arg = /*type0_____*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 11LLU);
43799- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43800- }
43801- {
43802- uint64_t arg = /*id0_______*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 10LLU);
43803- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43804- }
43805- {
43806- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 5LLU);
43807- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43808- }
43809- {
43810- uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 15LLU);
43811- LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43812- }
43813- {
43814- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 9LLU);
43815- LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43816- }
43817- {
43818- uint64_t arg = /*mutable0__*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 12LLU);
43819- LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43820- }
43821- {
43822- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 13LLU);
43823- LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43824- }
43825- {
43826- uint64_t arg = /*initialize*/LOCAL_ACCESS_ADDR(heap.data, 16LLU, 14LLU);
43827- LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43828- }
43829- {
43830- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 16LLU, 6LLU);
43831- LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43832- }
43833- {
43834- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 16LLU, 7LLU);
43835- LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43836- }
43837- {
43838- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 16LLU, 8LLU);
43839- LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43840- }
43841- // ACCUMULATE ARGUMENTS - END
43842- uint64_t return_to = 18446744073709549674LLU;
43843- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
43844- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43845- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43846- heap.data[0].elem1 = heap.data[0].elem0;
43847- heap.data[0].elem0 = restore;
43848- state.addr = 293363126232490310LLU; // PROCVARREF
43849- break;
43850- }
43851- case 18446744073709549674LLU: // 99999999fo'''''''''''''''
43852- {
43853- // variable u64 idx_______ goes out of scope
43854- // emitted destructur for type u64
43855- (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 16
43856- // variable u64 initialize goes out of scope
43857- // emitted destructur for type u64
43858- (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 15
43859- // variable u64 parameter_ goes out of scope
43860- // emitted destructur for type u64
43861- (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 14
43862- // ACCUMULATE ARGUMENTS - BEGIN
43863- {
43864- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 13LLU, 3LLU);
43865- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43866- }
43867- {
43868- uint64_t arg = /*type0_____*/LOCAL_ACCESS_ADDR(heap.data, 13LLU, 11LLU);
43869- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43870- }
43871- // ACCUMULATE ARGUMENTS - END
43872- uint64_t return_to = 18446744073709549673LLU;
43873- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
43874- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43875- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43876- heap.data[0].elem1 = heap.data[0].elem0;
43877- heap.data[0].elem0 = restore;
43878- state.addr = 517555565474237359LLU; // assertlist
43879- break;
43880- }
43881- case 18446744073709549673LLU: // 99999999fn'''''''''''''''
43882- {
43883- fprintf(stdout, "%s", ", &");
43884- // ACCUMULATE ARGUMENTS - BEGIN
43885- {
43886- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 13LLU, 5LLU);
43887- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43888- }
43889- // ACCUMULATE ARGUMENTS - END
43890- uint64_t return_to = 18446744073709549672LLU;
43891- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43892- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43893- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43894- heap.data[0].elem1 = heap.data[0].elem0;
43895- heap.data[0].elem0 = restore;
43896- state.addr = 839519665163075584LLU; // skip______
43897- break;
43898- }
43899- case 18446744073709549672LLU: // 99999999fm'''''''''''''''
43900- {
43901- matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
43902- // ACCUMULATE ARGUMENTS - BEGIN
43903- {
43904- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 13LLU, 5LLU);
43905- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43906- }
43907- // ACCUMULATE ARGUMENTS - END
43908- uint64_t return_to = 18446744073709549671LLU;
43909- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43910- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43911- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43912- heap.data[0].elem1 = heap.data[0].elem0;
43913- heap.data[0].elem0 = restore;
43914- state.addr = 839519665163075584LLU; // skip______
43915- break;
43916- }
43917- case 18446744073709549671LLU: // 99999999fl'''''''''''''''
43918- {
43919- {
43920- uint64_t arg = 0;
43921- LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43922- }
43923- // ACCUMULATE ARGUMENTS - BEGIN
43924- {
43925- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
43926- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43927- }
43928- // ACCUMULATE ARGUMENTS - END
43929- uint64_t return_to = 18446744073709549670LLU;
43930- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43931- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43932- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43933- heap.data[0].elem1 = heap.data[0].elem0;
43934- heap.data[0].elem0 = restore;
43935- state.addr = 861504796319285248LLU; // typeu64___
43936- break;
43937- }
43938- case 18446744073709549670LLU: // 99999999fk'''''''''''''''
43939- {
43940- {
43941- uint64_t arg = 0;
43942- LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43943- }
43944- *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0;
43945- // ACCUMULATE ARGUMENTS - BEGIN
43946- {
43947- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 15LLU, 5LLU);
43948- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43949- }
43950- // ACCUMULATE ARGUMENTS - END
43951- uint64_t return_to = 18446744073709549669LLU;
43952- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
43953- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
43954- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
43955- heap.data[0].elem1 = heap.data[0].elem0;
43956- heap.data[0].elem0 = restore;
43957- state.addr = 839519665163075584LLU; // skip______
43958- break;
43959- }
43960- case 18446744073709549669LLU: // 99999999fj'''''''''''''''
43961- {
43962-
43963- *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 5LLU)));
43964- {
43965- uint64_t arg = 0;
43966- LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43967- }
43968- *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 0;
43969- {
43970- uint64_t arg = 0;
43971- LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43972- }
43973- *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 0;
43974- {
43975- uint64_t arg = 0;
43976- LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43977- }
43978- *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = 0;
43979- {
43980- uint64_t arg = 0;
43981- LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43982- }
43983- *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 0;
43984- {
43985- uint64_t arg = 0;
43986- LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
43987- }
43988- *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
43989- // ACCUMULATE ARGUMENTS - BEGIN
43990- {
43991- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 20LLU, 3LLU);
43992- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43993- }
43994- {
43995- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 20LLU, 0LLU);
43996- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
43997- }
43998- {
43999- uint64_t arg = /*scopelist_*/*LOCAL_ACCESS(heap.data, 20LLU, 1LLU);
44000- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44001- }
44002- {
44003- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 20LLU, 2LLU);
44004- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44005- }
44006- {
44007- uint64_t arg = /*type1_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 13LLU);
44008- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44009- }
44010- {
44011- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 14LLU);
44012- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44013- }
44014- {
44015- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 20LLU, 5LLU);
44016- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44017- }
44018- {
44019- uint64_t arg = /*idx1______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 17LLU);
44020- LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44021- }
44022- {
44023- uint64_t arg = /*INDIRECT1_*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 15LLU);
44024- LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44025- }
44026- {
44027- uint64_t arg = /*mutable1__*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 16LLU);
44028- LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44029- }
44030- {
44031- uint64_t arg = /*parameter1*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 18LLU);
44032- LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44033- }
44034- {
44035- uint64_t arg = /*initialize*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
44036- LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44037- }
44038- {
44039- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 20LLU, 6LLU);
44040- LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44041- }
44042- {
44043- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 20LLU, 7LLU);
44044- LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44045- }
44046- {
44047- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 20LLU, 8LLU);
44048- LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44049- }
44050- // ACCUMULATE ARGUMENTS - END
44051- uint64_t return_to = 18446744073709549668LLU;
44052- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
44053- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44054- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44055- heap.data[0].elem1 = heap.data[0].elem0;
44056- heap.data[0].elem0 = restore;
44057- state.addr = 293363126232490310LLU; // PROCVARREF
44058- break;
44059- }
44060- case 18446744073709549668LLU: // 99999999fi'''''''''''''''
44061- {
44062- // ACCUMULATE ARGUMENTS - BEGIN
44063- {
44064- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 20LLU, 3LLU);
44065- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44066- }
44067- {
44068- uint64_t arg = /*type1_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 13LLU);
44069- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44070- }
44071- // ACCUMULATE ARGUMENTS - END
44072- uint64_t return_to = 18446744073709549667LLU;
44073- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
44074- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44075- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44076- heap.data[0].elem1 = heap.data[0].elem0;
44077- heap.data[0].elem0 = restore;
44078- state.addr = 517555565476695680LLU; // assertu64_
44079- break;
44080- }
44081- case 18446744073709549667LLU: // 99999999fh'''''''''''''''
44082- {
44083- {
44084- uint64_t arg = 0;
44085- LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44086- }
44087- *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 2;
44088- // ACCUMULATE ARGUMENTS - BEGIN
44089- {
44090- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 21LLU, 3LLU);
44091- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44092- }
44093- {
44094- uint64_t arg = /*callee_id_*/*LOCAL_ACCESS(heap.data, 21LLU, 4LLU);
44095- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44096- }
44097- {
44098- uint64_t arg = /*parnr_____*/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU);
44099- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44100- }
44101- {
44102- uint64_t arg = /*mutable1__*/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 16LLU);
44103- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44104- }
44105- {
44106- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 14LLU);
44107- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44108- }
44109- // ACCUMULATE ARGUMENTS - END
44110- uint64_t return_to = 18446744073709549666LLU;
44111- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
44112- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44113- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44114- heap.data[0].elem1 = heap.data[0].elem0;
44115- heap.data[0].elem0 = restore;
44116- state.addr = 734295421765213120LLU; // mutassert_
44117- break;
44118- }
44119- case 18446744073709549666LLU: // 99999999fg'''''''''''''''
44120- {
44121- // variable u64 parnr_____ goes out of scope
44122- // emitted destructur for type u64
44123- (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 21
44124- // variable u64 initialize goes out of scope
44125- // emitted destructur for type u64
44126- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 20
44127- // variable u64 parameter1 goes out of scope
44128- // emitted destructur for type u64
44129- (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter1 at 19
44130- // variable u64 idx1______ goes out of scope
44131- // emitted destructur for type u64
44132- (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx1______ at 18
44133- // variable u64 mutable1__ goes out of scope
44134- // emitted destructur for type u64
44135- (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 17
44136- // variable u64 INDIRECT1_ goes out of scope
44137- // emitted destructur for type u64
44138- (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT1_ at 16
44139- // variable u64 id1_______ goes out of scope
44140- // emitted destructur for type u64
44141- (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 15
44142- fprintf(stdout, "%s", ");");
44143- // ACCUMULATE ARGUMENTS - BEGIN
44144- {
44145- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 14LLU, 5LLU);
44146- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44147- }
44148- // ACCUMULATE ARGUMENTS - END
44149- uint64_t return_to = 18446744073709549665LLU;
44150- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44151- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44152- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44153- heap.data[0].elem1 = heap.data[0].elem0;
44154- heap.data[0].elem0 = restore;
44155- state.addr = 839519665163075584LLU; // skip______
44156- break;
44157- }
44158- case 18446744073709549665LLU: // 99999999ff'''''''''''''''
44159- {
44160- ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)), stdin);
44161- if(')' != (char)getchar())
44162- {
44163- fprintf(stderr, "match failed at char %c\n", (char)41LLU);
44164- exit(-1);
44165- }
44166- // variable type______ type1_____ goes out of scope
44167- // emitted destructur for type type______
44168- // ACCUMULATE ARGUMENTS - BEGIN
44169- {
44170- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
44171- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44172- }
44173- // ACCUMULATE ARGUMENTS - END
44174- uint64_t return_to = 18446744073709549664LLU;
44175- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44176- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44177- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44178- heap.data[0].elem1 = heap.data[0].elem0;
44179- heap.data[0].elem0 = restore;
44180- state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
44181- break;
44182- }
44183- case 18446744073709549664LLU: // 99999999fe'''''''''''''''
44184- {
44185- (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 14
44186- // variable u64 mutable0__ goes out of scope
44187- // emitted destructur for type u64
44188- (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 13
44189- // variable type______ type0_____ goes out of scope
44190- // emitted destructur for type type______
44191- // ACCUMULATE ARGUMENTS - BEGIN
44192- {
44193- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 12LLU, 11LLU);
44194- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44195- }
44196- // ACCUMULATE ARGUMENTS - END
44197- uint64_t return_to = 18446744073709549663LLU;
44198- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44199- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44200- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44201- heap.data[0].elem1 = heap.data[0].elem0;
44202- heap.data[0].elem0 = restore;
44203- state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
44204- break;
44205- }
44206- case 18446744073709549663LLU: // 99999999fd'''''''''''''''
44207- {
44208- (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 12
44209- // variable u64 id0_______ goes out of scope
44210- // emitted destructur for type u64
44211- (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id0_______ at 11
44212- // variable u64 INDIRECT__ goes out of scope
44213- // emitted destructur for type u64
44214- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 10
44215- // parameter-reference u64 remainsize goes out of scope
44216- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainsize at 9
44217- // parameter-reference u64 defbodysz_ goes out of scope
44218- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defbodysz_ at 8
44219- // parameter-reference u64 defargcnt_ goes out of scope
44220- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defargcnt_ at 7
44221- // parameter-reference u64 c_________ goes out of scope
44222- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 6
44223- // parameter-reference u64 callee_id_ goes out of scope
44224- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference callee_id_ at 5
44225- // parameter-reference u64 def_id____ goes out of scope
44226- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 4
44227- // parameter-reference list<varentry__> varlist___ goes out of scope
44228- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varlist___ at 3
44229- // parameter-reference list<scope_____> scopelist_ goes out of scope
44230- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference scopelist_ at 2
44231- // parameter-reference list<typedef___> typedefs__ goes out of scope
44232- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 1
44233- {
44234- uint64_t baseinfo = heap.data[0].elem1;
44235- struct pair pair = unpair(&heap, &baseinfo);
44236- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
44237- state.addr = pair.elem1;
44238- }
44239- break;
44240- }
4424143672 case 293363103966204160LLU: // PROCARGID_
4424243673 {
4424343674 {
@@ -44250,7 +43681,7 @@
4425043681 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4425143682 }
4425243683 // ACCUMULATE ARGUMENTS - END
44253- uint64_t return_to = 18446744073709549662LLU;
43684+ uint64_t return_to = 18446744073709549678LLU;
4425443685 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4425543686 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4425643687 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44259,7 +43690,7 @@
4425943690 state.addr = 861504796319285248LLU; // typeu64___
4426043691 break;
4426143692 }
44262- case 18446744073709549662LLU: // 99999999fc'''''''''''''''
43693+ case 18446744073709549678LLU: // 99999999fs'''''''''''''''
4426343694 {
4426443695 {
4426543696 uint64_t arg = 0;
@@ -44360,7 +43791,7 @@
4436043791 LOCAL_PUSH_MOVE(&heap, 17LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4436143792 }
4436243793 // ACCUMULATE ARGUMENTS - END
44363- uint64_t return_to = 18446744073709549661LLU;
43794+ uint64_t return_to = 18446744073709549677LLU;
4436443795 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/*address of closure-in-construction*/, 0));
4436543796 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4436643797 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44369,7 +43800,7 @@
4436943800 state.addr = 293363119789970567LLU; // PROCPARARG
4437043801 break;
4437143802 }
44372- case 18446744073709549661LLU: // 99999999fb'''''''''''''''
43803+ case 18446744073709549677LLU: // 99999999fr'''''''''''''''
4437343804 {
4437443805 // variable u64 INDIRECT__ goes out of scope
4437543806 // emitted destructur for type u64
@@ -44400,7 +43831,7 @@
4440043831 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4440143832 }
4440243833 // ACCUMULATE ARGUMENTS - END
44403- uint64_t return_to = 18446744073709549660LLU;
43834+ uint64_t return_to = 18446744073709549676LLU;
4440443835 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4440543836 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4440643837 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44409,7 +43840,7 @@
4440943840 state.addr = 861504774606571689LLU; // typeassign
4441043841 break;
4441143842 }
44412- case 18446744073709549660LLU: // 99999999fa'''''''''''''''
43843+ case 18446744073709549676LLU: // 99999999fq'''''''''''''''
4441343844 {
4441443845 {
4441543846 uint64_t arg = 0;
@@ -44442,7 +43873,7 @@
4444243873 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4444343874 }
4444443875 // ACCUMULATE ARGUMENTS - END
44445- uint64_t return_to = 18446744073709549659LLU;
43876+ uint64_t return_to = 18446744073709549675LLU;
4444643877 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
4444743878 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4444843879 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44451,7 +43882,7 @@
4445143882 state.addr = 734295547157569536LLU; // mutcheck__
4445243883 break;
4445343884 }
44454- case 18446744073709549659LLU: // 99999999f$'''''''''''''''
43885+ case 18446744073709549675LLU: // 99999999fp'''''''''''''''
4445543886 {
4445643887 // variable u64 revparnr__ goes out of scope
4445743888 // emitted destructur for type u64
@@ -44476,7 +43907,7 @@
4447643907 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4447743908 }
4447843909 // ACCUMULATE ARGUMENTS - END
44479- uint64_t return_to = 18446744073709549658LLU;
43910+ uint64_t return_to = 18446744073709549674LLU;
4448043911 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4448143912 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4448243913 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44485,7 +43916,7 @@
4448543916 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4448643917 break;
4448743918 }
44488- case 18446744073709549658LLU: // 99999999fZ'''''''''''''''
43919+ case 18446744073709549674LLU: // 99999999fo'''''''''''''''
4448943920 {
4449043921 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typearg___ at 21
4449143922 // parameter-reference u64 defrs_____ goes out of scope
@@ -44548,7 +43979,7 @@
4454843979 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4454943980 }
4455043981 // ACCUMULATE ARGUMENTS - END
44551- uint64_t return_to = 18446744073709549657LLU;
43982+ uint64_t return_to = 18446744073709549673LLU;
4455243983 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4455343984 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4455443985 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44557,7 +43988,7 @@
4455743988 state.addr = 517555565476695680LLU; // assertu64_
4455843989 break;
4455943990 }
44560- case 18446744073709549657LLU: // 99999999fY'''''''''''''''
43991+ case 18446744073709549673LLU: // 99999999fn'''''''''''''''
4456143992 {
4456243993 {
4456343994 uint64_t arg = 0;
@@ -44564,11 +43995,11 @@
4456443995 LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4456543996 }
4456643997 *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU));
44567- state.addr = *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709549656LLU : 18446744073709549655LLU;
43998+ state.addr = *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709549672LLU : 18446744073709549671LLU;
4456843999 (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10
4456944000 break;
4457044001 }
44571- case 18446744073709549656LLU: // 99999999fX'''''''''''''''
44002+ case 18446744073709549672LLU: // 99999999fm'''''''''''''''
4457244003 {
4457344004 fprintf(stderr, "%s", "can't assign value ");
4457444005 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44577,7 +44008,7 @@
4457744008 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4457844009 }
4457944010 // ACCUMULATE ARGUMENTS - END
44580- uint64_t return_to = 18446744073709549654LLU;
44011+ uint64_t return_to = 18446744073709549670LLU;
4458144012 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4458244013 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4458344014 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44586,7 +44017,7 @@
4458644017 state.addr = 819847183517274112LLU; // reportnr__
4458744018 break;
4458844019 }
44589- case 18446744073709549654LLU: // 99999999fV'''''''''''''''
44020+ case 18446744073709549670LLU: // 99999999fk'''''''''''''''
4459044021 {
4459144022 fprintf(stderr, "%s", " to reference-parameter ");
4459244023 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44595,7 +44026,7 @@
4459544026 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4459644027 }
4459744028 // ACCUMULATE ARGUMENTS - END
44598- uint64_t return_to = 18446744073709549653LLU;
44029+ uint64_t return_to = 18446744073709549669LLU;
4459944030 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4460044031 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4460144032 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44604,16 +44035,16 @@
4460444035 state.addr = 819847183517274112LLU; // reportnr__
4460544036 break;
4460644037 }
44607- case 18446744073709549653LLU: // 99999999fU'''''''''''''''
44038+ case 18446744073709549669LLU: // 99999999fj'''''''''''''''
4460844039 {
4460944040 {
4461044041 fprintf(stderr, "%s\n", "");
4461144042 exit(-1);
4461244043 }
44613- state.addr = 18446744073709549655LLU; // 99999999fW'''''''''''''''
44044+ state.addr = 18446744073709549671LLU; // 99999999fl'''''''''''''''
4461444045 break;
4461544046 }
44616- case 18446744073709549655LLU: // 99999999fW'''''''''''''''
44047+ case 18446744073709549671LLU: // 99999999fl'''''''''''''''
4461744048 {
4461844049 // ACCUMULATE ARGUMENTS - BEGIN
4461944050 {
@@ -44621,7 +44052,7 @@
4462144052 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4462244053 }
4462344054 // ACCUMULATE ARGUMENTS - END
44624- uint64_t return_to = 18446744073709549652LLU;
44055+ uint64_t return_to = 18446744073709549668LLU;
4462544056 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4462644057 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4462744058 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44630,7 +44061,7 @@
4463044061 state.addr = 787446708198178816LLU; // printnr___
4463144062 break;
4463244063 }
44633- case 18446744073709549652LLU: // 99999999fT'''''''''''''''
44064+ case 18446744073709549668LLU: // 99999999fi'''''''''''''''
4463444065 {
4463544066 // parameter-reference u64 tmprs_____ goes out of scope
4463644067 (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmprs_____ at 9
@@ -44679,11 +44110,11 @@
4467944110 LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4468044111 }
4468144112 *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*overflow__*/*LOCAL_ACCESS(heap.data, 8LLU, 6LLU);
44682- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709549651LLU : 18446744073709549650LLU;
44113+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709549667LLU : 18446744073709549666LLU;
4468344114 (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
4468444115 break;
4468544116 }
44686- case 18446744073709549651LLU: // 99999999fS'''''''''''''''
44117+ case 18446744073709549667LLU: // 99999999fh'''''''''''''''
4468744118 {
4468844119 fprintf(stderr, "%s", "out of memory calling function ");
4468944120 printid(stderr, /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU)));
@@ -44694,7 +44125,7 @@
4469444125 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4469544126 }
4469644127 // ACCUMULATE ARGUMENTS - END
44697- uint64_t return_to = 18446744073709549649LLU;
44128+ uint64_t return_to = 18446744073709549665LLU;
4469844129 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4469944130 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4470044131 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44703,7 +44134,7 @@
4470344134 state.addr = 819847183517274112LLU; // reportnr__
4470444135 break;
4470544136 }
44706- case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
44137+ case 18446744073709549665LLU: // 99999999ff'''''''''''''''
4470744138 {
4470844139 fprintf(stderr, "%s", " chunks of memory but caller ");
4470944140 printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)));
@@ -44714,7 +44145,7 @@
4471444145 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4471544146 }
4471644147 // ACCUMULATE ARGUMENTS - END
44717- uint64_t return_to = 18446744073709549648LLU;
44148+ uint64_t return_to = 18446744073709549664LLU;
4471844149 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4471944150 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4472044151 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44723,16 +44154,16 @@
4472344154 state.addr = 819847183517274112LLU; // reportnr__
4472444155 break;
4472544156 }
44726- case 18446744073709549648LLU: // 99999999fP'''''''''''''''
44157+ case 18446744073709549664LLU: // 99999999fe'''''''''''''''
4472744158 {
4472844159 {
4472944160 fprintf(stderr, "%s\n", "");
4473044161 exit(-1);
4473144162 }
44732- state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
44163+ state.addr = 18446744073709549666LLU; // 99999999fg'''''''''''''''
4473344164 break;
4473444165 }
44735- case 18446744073709549650LLU: // 99999999fR'''''''''''''''
44166+ case 18446744073709549666LLU: // 99999999fg'''''''''''''''
4473644167 {
4473744168 // variable u64 overflow__ goes out of scope
4473844169 // emitted destructur for type u64
@@ -44797,10 +44228,10 @@
4479744228 uint64_t arg = 0;
4479844229 LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4479944230 }
44800- state.addr = 18446744073709549647LLU; // 99999999fO'''''''''''''''
44231+ state.addr = 18446744073709549663LLU; // 99999999fd'''''''''''''''
4480144232 break;
4480244233 }
44803- case 18446744073709549647LLU: // 99999999fO'''''''''''''''
44234+ case 18446744073709549663LLU: // 99999999fd'''''''''''''''
4480444235 {
4480544236 if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
4480644237 {
@@ -44807,7 +44238,7 @@
4480744238 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
4480844239 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4480944240 {
44810- state.addr = 18446744073709549646LLU; // 99999999fN'''''''''''''''
44241+ state.addr = 18446744073709549662LLU; // 99999999fc'''''''''''''''
4481144242 break;
4481244243 }
4481344244 }
@@ -44827,7 +44258,7 @@
4482744258 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4482844259 }
4482944260 // ACCUMULATE ARGUMENTS - END
44830- uint64_t return_to = 18446744073709549642LLU;
44261+ uint64_t return_to = 18446744073709549658LLU;
4483144262 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4483244263 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4483344264 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44836,12 +44267,12 @@
4483644267 state.addr = 325750391286068249LLU; // RESDEFCOPY
4483744268 break;
4483844269 }
44839- case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
44270+ case 18446744073709549658LLU: // 99999999fZ'''''''''''''''
4484044271 {
44841- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709549645LLU : 18446744073709549644LLU;
44272+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709549661LLU : 18446744073709549660LLU;
4484244273 break;
4484344274 }
44844- case 18446744073709549645LLU: // 99999999fM'''''''''''''''
44275+ case 18446744073709549661LLU: // 99999999fb'''''''''''''''
4484544276 {
4484644277 fprintf(stderr, "%s", "pushing res ");
4484744278 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44850,7 +44281,7 @@
4485044281 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4485144282 }
4485244283 // ACCUMULATE ARGUMENTS - END
44853- uint64_t return_to = 18446744073709549641LLU;
44284+ uint64_t return_to = 18446744073709549657LLU;
4485444285 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4485544286 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4485644287 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44859,7 +44290,7 @@
4485944290 state.addr = 819847183518272384LLU; // reportres_
4486044291 break;
4486144292 }
44862- case 18446744073709549641LLU: // 99999999fI'''''''''''''''
44293+ case 18446744073709549657LLU: // 99999999fY'''''''''''''''
4486344294 {
4486444295 fprintf(stderr, "%s", "\n");
4486544296 {
@@ -44873,7 +44304,7 @@
4487344304 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4487444305 }
4487544306 // ACCUMULATE ARGUMENTS - END
44876- uint64_t return_to = 18446744073709549640LLU;
44307+ uint64_t return_to = 18446744073709549656LLU;
4487744308 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4487844309 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4487944310 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44882,26 +44313,26 @@
4488244313 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4488344314 break;
4488444315 }
44885- case 18446744073709549640LLU: // 99999999fH'''''''''''''''
44316+ case 18446744073709549656LLU: // 99999999fX'''''''''''''''
4488644317 {
4488744318 // parameter resdest___ new_______ goes out of scope
44888- state.addr = 18446744073709549643LLU; // 99999999fK'''''''''''''''
44319+ state.addr = 18446744073709549659LLU; // 99999999f$'''''''''''''''
4488944320 break;
4489044321 }
44891- case 18446744073709549644LLU: // 99999999fL'''''''''''''''
44322+ case 18446744073709549660LLU: // 99999999fa'''''''''''''''
4489244323 {
44893- state.addr = 18446744073709549643LLU; // 99999999fK'''''''''''''''
44324+ state.addr = 18446744073709549659LLU; // 99999999f$'''''''''''''''
4489444325 break;
4489544326 }
44896- case 18446744073709549643LLU: // 99999999fK'''''''''''''''
44327+ case 18446744073709549659LLU: // 99999999f$'''''''''''''''
4489744328 {
4489844329 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
4489944330 // parameter-reference resdest___ res_______ goes out of scope
4490044331 // parameter-reference list<resdest___> results___ goes out of scope
44901- state.addr = 18446744073709549647LLU; // 99999999fO'''''''''''''''
44332+ state.addr = 18446744073709549663LLU; // 99999999fd'''''''''''''''
4490244333 break;
4490344334 }
44904- case 18446744073709549646LLU: // 99999999fN'''''''''''''''
44335+ case 18446744073709549662LLU: // 99999999fc'''''''''''''''
4490544336 {
4490644337 {
4490744338 uint64_t arg = 0;
@@ -44974,7 +44405,7 @@
4497444405 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4497544406 }
4497644407 // ACCUMULATE ARGUMENTS - END
44977- uint64_t return_to = 18446744073709549638LLU;
44408+ uint64_t return_to = 18446744073709549654LLU;
4497844409 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0));
4497944410 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4498044411 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44983,7 +44414,7 @@
4498344414 state.addr = 608168382267297792LLU; // function__
4498444415 break;
4498544416 }
44986- case 18446744073709549638LLU: // 99999999fF'''''''''''''''
44417+ case 18446744073709549654LLU: // 99999999fV'''''''''''''''
4498744418 {
4498844419 {
4498944420 uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/;
@@ -44999,7 +44430,7 @@
4499944430 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4500044431 }
4500144432 // ACCUMULATE ARGUMENTS - END
45002- uint64_t return_to = 18446744073709549639LLU;
44433+ uint64_t return_to = 18446744073709549655LLU;
4500344434 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4500444435 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4500544436 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45008,7 +44439,7 @@
4500844439 state.addr = 567601196335104000LLU; // defidfn___
4500944440 break;
4501044441 }
45011- case 18446744073709549639LLU: // 99999999fG'''''''''''''''
44442+ case 18446744073709549655LLU: // 99999999fW'''''''''''''''
4501244443 {
4501344444 // variable u64 defined___ goes out of scope
4501444445 // (uninitialized -> no destructor-call)
@@ -45083,7 +44514,7 @@
4508344514 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4508444515 }
4508544516 // ACCUMULATE ARGUMENTS - END
45086- uint64_t return_to = 18446744073709549637LLU;
44517+ uint64_t return_to = 18446744073709549653LLU;
4508744518 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4508844519 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4508944520 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45092,7 +44523,7 @@
4509244523 state.addr = 367395560426147840LLU; // TYPECOPY__
4509344524 break;
4509444525 }
45095- case 18446744073709549637LLU: // 99999999fE'''''''''''''''
44526+ case 18446744073709549653LLU: // 99999999fU'''''''''''''''
4509644527 {
4509744528 {
4509844529 uint64_t arg = 0;
@@ -45126,7 +44557,7 @@
4512644557 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4512744558 }
4512844559 // ACCUMULATE ARGUMENTS - END
45129- uint64_t return_to = 18446744073709549633LLU;
44560+ uint64_t return_to = 18446744073709549649LLU;
4513044561 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4513144562 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4513244563 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45135,12 +44566,12 @@
4513544566 state.addr = 819859607768530944LLU; // resdest___
4513644567 break;
4513744568 }
45138- case 18446744073709549633LLU: // 99999999fA'''''''''''''''
44569+ case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
4513944570 {
45140- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)), 8) ? 18446744073709549636LLU : 18446744073709549635LLU;
44571+ 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;
4514144572 break;
4514244573 }
45143- case 18446744073709549636LLU: // 99999999fD'''''''''''''''
44574+ case 18446744073709549652LLU: // 99999999fT'''''''''''''''
4514444575 {
4514544576 {
4514644577 fprintf(stderr, "%s\n", "INTERNAL ERROR - out of dynamic heap in oneresult - recompile compiler with more dynamic heap");
@@ -45153,7 +44584,7 @@
4515344584 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4515444585 }
4515544586 // ACCUMULATE ARGUMENTS - END
45156- uint64_t return_to = 18446744073709549632LLU;
44587+ uint64_t return_to = 18446744073709549648LLU;
4515744588 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4515844589 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4515944590 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45162,18 +44593,18 @@
4516244593 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4516344594 break;
4516444595 }
45165- case 18446744073709549632LLU: // 99999999f_'''''''''''''''
44596+ case 18446744073709549648LLU: // 99999999fP'''''''''''''''
4516644597 {
4516744598 // parameter resdest___ tmp_______ goes out of scope
45168- state.addr = 18446744073709549634LLU; // 99999999fB'''''''''''''''
44599+ state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
4516944600 break;
4517044601 }
45171- case 18446744073709549635LLU: // 99999999fC'''''''''''''''
44602+ case 18446744073709549651LLU: // 99999999fS'''''''''''''''
4517244603 {
45173- state.addr = 18446744073709549634LLU; // 99999999fB'''''''''''''''
44604+ state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
4517444605 break;
4517544606 }
45176- case 18446744073709549634LLU: // 99999999fB'''''''''''''''
44607+ case 18446744073709549650LLU: // 99999999fR'''''''''''''''
4517744608 {
4517844609 (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
4517944610 // variable u64 reference_ goes out of scope
@@ -45214,11 +44645,11 @@
4521444645 LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4521544646 }
4521644647 *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*sz________*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
45217- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549631LLU : 18446744073709549630LLU;
44648+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549647LLU : 18446744073709549646LLU;
4521844649 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4521944650 break;
4522044651 }
45221- case 18446744073709549631LLU: // 99999999e9'''''''''''''''
44652+ case 18446744073709549647LLU: // 99999999fO'''''''''''''''
4522244653 {
4522344654 ++/*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
4522444655 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45227,7 +44658,7 @@
4522744658 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4522844659 }
4522944660 // ACCUMULATE ARGUMENTS - END
45230- uint64_t return_to = 18446744073709549629LLU;
44661+ uint64_t return_to = 18446744073709549645LLU;
4523144662 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4523244663 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4523344664 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45236,7 +44667,7 @@
4523644667 state.addr = 819847183515949359LLU; // reportinit
4523744668 break;
4523844669 }
45239- case 18446744073709549629LLU: // 99999999e7'''''''''''''''
44670+ case 18446744073709549645LLU: // 99999999fM'''''''''''''''
4524044671 {
4524144672 fprintf(stderr, "%s", "built-in function returns (u64) but caller expects ");
4524244673 fprintf(stderr, "%llu", (unsigned long long)/*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));
@@ -45245,10 +44676,10 @@
4524544676 fprintf(stderr, "%s\n", "");
4524644677 exit(-1);
4524744678 }
45248- state.addr = 18446744073709549630LLU; // 99999999e8'''''''''''''''
44679+ state.addr = 18446744073709549646LLU; // 99999999fN'''''''''''''''
4524944680 break;
4525044681 }
45251- case 18446744073709549630LLU: // 99999999e8'''''''''''''''
44682+ case 18446744073709549646LLU: // 99999999fN'''''''''''''''
4525244683 {
4525344684 {
4525444685 uint64_t arg = /*res_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
@@ -45258,10 +44689,10 @@
4525844689 uint64_t arg = 0;
4525944690 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4526044691 }
45261- state.addr = 18446744073709549628LLU; // 99999999e6'''''''''''''''
44692+ state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
4526244693 break;
4526344694 }
45264- case 18446744073709549628LLU: // 99999999e6'''''''''''''''
44695+ case 18446744073709549644LLU: // 99999999fL'''''''''''''''
4526544696 {
4526644697 if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
4526744698 {
@@ -45268,7 +44699,7 @@
4526844699 (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
4526944700 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4527044701 {
45271- state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
44702+ state.addr = 18446744073709549643LLU; // 99999999fK'''''''''''''''
4527244703 break;
4527344704 }
4527444705 }
@@ -45282,7 +44713,7 @@
4528244713 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4528344714 }
4528444715 // ACCUMULATE ARGUMENTS - END
45285- uint64_t return_to = 18446744073709549626LLU;
44716+ uint64_t return_to = 18446744073709549642LLU;
4528644717 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4528744718 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4528844719 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45291,7 +44722,7 @@
4529144722 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4529244723 break;
4529344724 }
45294- case 18446744073709549626LLU: // 99999999e4'''''''''''''''
44725+ case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
4529544726 {
4529644727 // ACCUMULATE ARGUMENTS - BEGIN
4529744728 {
@@ -45303,7 +44734,7 @@
4530344734 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4530444735 }
4530544736 // ACCUMULATE ARGUMENTS - END
45306- uint64_t return_to = 18446744073709549625LLU;
44737+ uint64_t return_to = 18446744073709549641LLU;
4530744738 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4530844739 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4530944740 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45312,14 +44743,14 @@
4531244743 state.addr = 325750391286068249LLU; // RESDEFCOPY
4531344744 break;
4531444745 }
45315- case 18446744073709549625LLU: // 99999999e3'''''''''''''''
44746+ case 18446744073709549641LLU: // 99999999fI'''''''''''''''
4531644747 {
4531744748 // parameter-reference resdest___ tmp_______ goes out of scope
4531844749 // parameter-reference list<resdest___> res_______ goes out of scope
45319- state.addr = 18446744073709549628LLU; // 99999999e6'''''''''''''''
44750+ state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
4532044751 break;
4532144752 }
45322- case 18446744073709549627LLU: // 99999999e5'''''''''''''''
44753+ case 18446744073709549643LLU: // 99999999fK'''''''''''''''
4532344754 {
4532444755 // variable u64 sz________ goes out of scope
4532544756 // emitted destructur for type u64
@@ -45353,11 +44784,11 @@
4535344784 LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4535444785 }
4535544786 *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*sz________*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
45356- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549624LLU : 18446744073709549623LLU;
44787+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549640LLU : 18446744073709549639LLU;
4535744788 (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
4535844789 break;
4535944790 }
45360- case 18446744073709549624LLU: // 99999999e2'''''''''''''''
44791+ case 18446744073709549640LLU: // 99999999fH'''''''''''''''
4536144792 {
4536244793 ++/*sz________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
4536344794 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45366,7 +44797,7 @@
4536644797 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4536744798 }
4536844799 // ACCUMULATE ARGUMENTS - END
45369- uint64_t return_to = 18446744073709549622LLU;
44800+ uint64_t return_to = 18446744073709549638LLU;
4537044801 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4537144802 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4537244803 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45375,7 +44806,7 @@
4537544806 state.addr = 819847183515949359LLU; // reportinit
4537644807 break;
4537744808 }
45378- case 18446744073709549622LLU: // 99999999e0'''''''''''''''
44809+ case 18446744073709549638LLU: // 99999999fF'''''''''''''''
4537944810 {
4538044811 fprintf(stderr, "%s", "found ");
4538144812 fprintf(stderr, "%llu", (unsigned long long)/*sz________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
@@ -45384,10 +44815,10 @@
4538444815 fprintf(stderr, "%s\n", "");
4538544816 exit(-1);
4538644817 }
45387- state.addr = 18446744073709549623LLU; // 99999999e1'''''''''''''''
44818+ state.addr = 18446744073709549639LLU; // 99999999fG'''''''''''''''
4538844819 break;
4538944820 }
45390- case 18446744073709549623LLU: // 99999999e1'''''''''''''''
44821+ case 18446744073709549639LLU: // 99999999fG'''''''''''''''
4539144822 {
4539244823 {
4539344824 uint64_t arg = 0;
@@ -45412,7 +44843,7 @@
4541244843 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4541344844 }
4541444845 // ACCUMULATE ARGUMENTS - END
45415- uint64_t return_to = 18446744073709549620LLU;
44846+ uint64_t return_to = 18446744073709549636LLU;
4541644847 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4541744848 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4541844849 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45421,7 +44852,7 @@
4542144852 state.addr = 861504796319285248LLU; // typeu64___
4542244853 break;
4542344854 }
45424- case 18446744073709549620LLU: // 99999999ey'''''''''''''''
44855+ case 18446744073709549636LLU: // 99999999fD'''''''''''''''
4542544856 {
4542644857 {
4542744858 uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
@@ -45441,7 +44872,7 @@
4544144872 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4544244873 }
4544344874 // ACCUMULATE ARGUMENTS - END
45444- uint64_t return_to = 18446744073709549621LLU;
44875+ uint64_t return_to = 18446744073709549637LLU;
4544544876 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4544644877 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4544744878 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45450,7 +44881,7 @@
4545044881 state.addr = 819859607768530944LLU; // resdest___
4545144882 break;
4545244883 }
45453- case 18446744073709549621LLU: // 99999999ez'''''''''''''''
44884+ case 18446744073709549637LLU: // 99999999fE'''''''''''''''
4545444885 {
4545544886 {
4545644887 uint64_t arg = /*res_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU));
@@ -45460,10 +44891,10 @@
4546044891 uint64_t arg = 0;
4546144892 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4546244893 }
45463- state.addr = 18446744073709549619LLU; // 99999999ex'''''''''''''''
44894+ state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
4546444895 break;
4546544896 }
45466- case 18446744073709549619LLU: // 99999999ex'''''''''''''''
44897+ case 18446744073709549635LLU: // 99999999fC'''''''''''''''
4546744898 {
4546844899 if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
4546944900 {
@@ -45470,7 +44901,7 @@
4547044901 (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
4547144902 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
4547244903 {
45473- state.addr = 18446744073709549618LLU; // 99999999ew'''''''''''''''
44904+ state.addr = 18446744073709549634LLU; // 99999999fB'''''''''''''''
4547444905 break;
4547544906 }
4547644907 }
@@ -45484,7 +44915,7 @@
4548444915 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4548544916 }
4548644917 // ACCUMULATE ARGUMENTS - END
45487- uint64_t return_to = 18446744073709549617LLU;
44918+ uint64_t return_to = 18446744073709549633LLU;
4548844919 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4548944920 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4549044921 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45493,7 +44924,7 @@
4549344924 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4549444925 break;
4549544926 }
45496- case 18446744073709549617LLU: // 99999999ev'''''''''''''''
44927+ case 18446744073709549633LLU: // 99999999fA'''''''''''''''
4549744928 {
4549844929 // ACCUMULATE ARGUMENTS - BEGIN
4549944930 {
@@ -45505,7 +44936,7 @@
4550544936 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4550644937 }
4550744938 // ACCUMULATE ARGUMENTS - END
45508- uint64_t return_to = 18446744073709549616LLU;
44939+ uint64_t return_to = 18446744073709549632LLU;
4550944940 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4551044941 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4551144942 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45514,14 +44945,14 @@
4551444945 state.addr = 325750391286068249LLU; // RESDEFCOPY
4551544946 break;
4551644947 }
45517- case 18446744073709549616LLU: // 99999999eu'''''''''''''''
44948+ case 18446744073709549632LLU: // 99999999f_'''''''''''''''
4551844949 {
4551944950 // parameter-reference resdest___ tmp_______ goes out of scope
4552044951 // parameter-reference list<resdest___> res_______ goes out of scope
45521- state.addr = 18446744073709549619LLU; // 99999999ex'''''''''''''''
44952+ state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
4552244953 break;
4552344954 }
45524- case 18446744073709549618LLU: // 99999999ew'''''''''''''''
44955+ case 18446744073709549634LLU: // 99999999fB'''''''''''''''
4552544956 {
4552644957 swap(&*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
4552744958 // variable resdest___ single____ goes out of scope
@@ -45563,7 +44994,7 @@
4556344994 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4556444995 }
4556544996 // ACCUMULATE ARGUMENTS - END
45566- uint64_t return_to = 18446744073709549615LLU;
44997+ uint64_t return_to = 18446744073709549631LLU;
4556744998 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4556844999 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4556945000 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45572,7 +45003,7 @@
4557245003 state.addr = 819857492327934432LLU; // res_single
4557345004 break;
4557445005 }
45575- case 18446744073709549615LLU: // 99999999et'''''''''''''''
45006+ case 18446744073709549631LLU: // 99999999e9'''''''''''''''
4557645007 {
4557745008 // ACCUMULATE ARGUMENTS - BEGIN
4557845009 {
@@ -45584,7 +45015,7 @@
4558445015 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4558545016 }
4558645017 // ACCUMULATE ARGUMENTS - END
45587- uint64_t return_to = 18446744073709549614LLU;
45018+ uint64_t return_to = 18446744073709549630LLU;
4558845019 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4558945020 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4559045021 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45593,7 +45024,7 @@
4559345024 state.addr = 517555565476695680LLU; // assertu64_
4559445025 break;
4559545026 }
45596- case 18446744073709549614LLU: // 99999999es'''''''''''''''
45027+ case 18446744073709549630LLU: // 99999999e8'''''''''''''''
4559745028 {
4559845029 // parameter-reference list<resdest___> res_______ goes out of scope
4559945030 (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res_______ at 4
@@ -45627,11 +45058,11 @@
4562745058 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4562845059 }
4562945060 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45630- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549613LLU : 18446744073709549612LLU;
45061+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549629LLU : 18446744073709549628LLU;
4563145062 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4563245063 break;
4563345064 }
45634- case 18446744073709549613LLU: // 99999999er'''''''''''''''
45065+ case 18446744073709549629LLU: // 99999999e7'''''''''''''''
4563545066 {
4563645067 {
4563745068 uint64_t arg = 0;
@@ -45656,7 +45087,7 @@
4565645087 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4565745088 }
4565845089 // ACCUMULATE ARGUMENTS - END
45659- uint64_t return_to = 18446744073709549609LLU;
45090+ uint64_t return_to = 18446744073709549625LLU;
4566045091 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4566145092 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4566245093 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45665,7 +45096,7 @@
4566545096 state.addr = 861504796319285248LLU; // typeu64___
4566645097 break;
4566745098 }
45668- case 18446744073709549609LLU: // 99999999en'''''''''''''''
45099+ case 18446744073709549625LLU: // 99999999e3'''''''''''''''
4566945100 {
4567045101 {
4567145102 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -45685,7 +45116,7 @@
4568545116 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4568645117 }
4568745118 // ACCUMULATE ARGUMENTS - END
45688- uint64_t return_to = 18446744073709549610LLU;
45119+ uint64_t return_to = 18446744073709549626LLU;
4568945120 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4569045121 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4569145122 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45694,7 +45125,7 @@
4569445125 state.addr = 819859607768530944LLU; // resdest___
4569545126 break;
4569645127 }
45697- case 18446744073709549610LLU: // 99999999eo'''''''''''''''
45128+ case 18446744073709549626LLU: // 99999999e4'''''''''''''''
4569845129 {
4569945130 // ACCUMULATE ARGUMENTS - BEGIN
4570045131 {
@@ -45714,7 +45145,7 @@
4571445145 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4571545146 }
4571645147 // ACCUMULATE ARGUMENTS - END
45717- uint64_t return_to = 18446744073709549608LLU;
45148+ uint64_t return_to = 18446744073709549624LLU;
4571845149 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4571945150 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4572045151 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45723,7 +45154,7 @@
4572345154 state.addr = 819857494882385920LLU; // res_u64___
4572445155 break;
4572545156 }
45726- case 18446744073709549608LLU: // 99999999em'''''''''''''''
45157+ case 18446744073709549624LLU: // 99999999e2'''''''''''''''
4572745158 {
4572845159 // ACCUMULATE ARGUMENTS - BEGIN
4572945160 {
@@ -45731,7 +45162,7 @@
4573145162 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4573245163 }
4573345164 // ACCUMULATE ARGUMENTS - END
45734- uint64_t return_to = 18446744073709549607LLU;
45165+ uint64_t return_to = 18446744073709549623LLU;
4573545166 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4573645167 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4573745168 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45740,7 +45171,7 @@
4574045171 state.addr = 839519665163075584LLU; // skip______
4574145172 break;
4574245173 }
45743- case 18446744073709549607LLU: // 99999999el'''''''''''''''
45174+ case 18446744073709549623LLU: // 99999999e1'''''''''''''''
4574445175 {
4574545176 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4574645177 fprintf(stdout, "%s", "\n ");
@@ -45766,7 +45197,7 @@
4576645197 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4576745198 }
4576845199 // ACCUMULATE ARGUMENTS - END
45769- uint64_t return_to = 18446744073709549606LLU;
45200+ uint64_t return_to = 18446744073709549622LLU;
4577045201 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4577145202 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4577245203 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45775,7 +45206,7 @@
4577545206 state.addr = 587881357514113024LLU; // emitpar___
4577645207 break;
4577745208 }
45778- case 18446744073709549606LLU: // 99999999ek'''''''''''''''
45209+ case 18446744073709549622LLU: // 99999999e0'''''''''''''''
4577945210 {
4578045211 fprintf(stdout, "%s", " = (uint64_t)getchar();");
4578145212 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45784,7 +45215,7 @@
4578445215 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4578545216 }
4578645217 // ACCUMULATE ARGUMENTS - END
45787- uint64_t return_to = 18446744073709549605LLU;
45218+ uint64_t return_to = 18446744073709549621LLU;
4578845219 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4578945220 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4579045221 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45793,7 +45224,7 @@
4579345224 state.addr = 839519665163075584LLU; // skip______
4579445225 break;
4579545226 }
45796- case 18446744073709549605LLU: // 99999999ej'''''''''''''''
45227+ case 18446744073709549621LLU: // 99999999ez'''''''''''''''
4579745228 {
4579845229 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4579945230 // variable resdest___ single____ goes out of scope
@@ -45804,7 +45235,7 @@
4580445235 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4580545236 }
4580645237 // ACCUMULATE ARGUMENTS - END
45807- uint64_t return_to = 18446744073709549604LLU;
45238+ uint64_t return_to = 18446744073709549620LLU;
4580845239 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4580945240 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4581045241 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45813,13 +45244,13 @@
4581345244 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4581445245 break;
4581545246 }
45816- case 18446744073709549604LLU: // 99999999ei'''''''''''''''
45247+ case 18446744073709549620LLU: // 99999999ey'''''''''''''''
4581745248 {
4581845249 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
45819- state.addr = 18446744073709549611LLU; // 99999999ep'''''''''''''''
45250+ state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
4582045251 break;
4582145252 }
45822- case 18446744073709549612LLU: // 99999999eq'''''''''''''''
45253+ case 18446744073709549628LLU: // 99999999e6'''''''''''''''
4582345254 {
4582445255
4582545256 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 783769716797919232;
@@ -45830,11 +45261,11 @@
4583045261 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4583145262 }
4583245263 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45833- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549603LLU : 18446744073709549602LLU;
45264+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549619LLU : 18446744073709549618LLU;
4583445265 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4583545266 break;
4583645267 }
45837- case 18446744073709549603LLU: // 99999999eh'''''''''''''''
45268+ case 18446744073709549619LLU: // 99999999ex'''''''''''''''
4583845269 {
4583945270 {
4584045271 uint64_t arg = 0;
@@ -45859,7 +45290,7 @@
4585945290 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4586045291 }
4586145292 // ACCUMULATE ARGUMENTS - END
45862- uint64_t return_to = 18446744073709549599LLU;
45293+ uint64_t return_to = 18446744073709549615LLU;
4586345294 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4586445295 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4586545296 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45868,7 +45299,7 @@
4586845299 state.addr = 861504796319285248LLU; // typeu64___
4586945300 break;
4587045301 }
45871- case 18446744073709549599LLU: // 99999999ed'''''''''''''''
45302+ case 18446744073709549615LLU: // 99999999et'''''''''''''''
4587245303 {
4587345304 {
4587445305 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -45888,7 +45319,7 @@
4588845319 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4588945320 }
4589045321 // ACCUMULATE ARGUMENTS - END
45891- uint64_t return_to = 18446744073709549600LLU;
45322+ uint64_t return_to = 18446744073709549616LLU;
4589245323 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4589345324 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4589445325 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45897,7 +45328,7 @@
4589745328 state.addr = 819859607768530944LLU; // resdest___
4589845329 break;
4589945330 }
45900- case 18446744073709549600LLU: // 99999999ee'''''''''''''''
45331+ case 18446744073709549616LLU: // 99999999eu'''''''''''''''
4590145332 {
4590245333 // ACCUMULATE ARGUMENTS - BEGIN
4590345334 {
@@ -45917,7 +45348,7 @@
4591745348 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4591845349 }
4591945350 // ACCUMULATE ARGUMENTS - END
45920- uint64_t return_to = 18446744073709549598LLU;
45351+ uint64_t return_to = 18446744073709549614LLU;
4592145352 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4592245353 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4592345354 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45926,7 +45357,7 @@
4592645357 state.addr = 819857494882385920LLU; // res_u64___
4592745358 break;
4592845359 }
45929- case 18446744073709549598LLU: // 99999999ec'''''''''''''''
45360+ case 18446744073709549614LLU: // 99999999es'''''''''''''''
4593045361 {
4593145362 // ACCUMULATE ARGUMENTS - BEGIN
4593245363 {
@@ -45934,7 +45365,7 @@
4593445365 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4593545366 }
4593645367 // ACCUMULATE ARGUMENTS - END
45937- uint64_t return_to = 18446744073709549597LLU;
45368+ uint64_t return_to = 18446744073709549613LLU;
4593845369 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4593945370 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4594045371 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45943,7 +45374,7 @@
4594345374 state.addr = 839519665163075584LLU; // skip______
4594445375 break;
4594545376 }
45946- case 18446744073709549597LLU: // 99999999eb'''''''''''''''
45377+ case 18446744073709549613LLU: // 99999999er'''''''''''''''
4594745378 {
4594845379 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4594945380 fprintf(stdout, "%s", "\n ");
@@ -45969,7 +45400,7 @@
4596945400 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4597045401 }
4597145402 // ACCUMULATE ARGUMENTS - END
45972- uint64_t return_to = 18446744073709549596LLU;
45403+ uint64_t return_to = 18446744073709549612LLU;
4597345404 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4597445405 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4597545406 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45978,7 +45409,7 @@
4597845409 state.addr = 587881357514113024LLU; // emitpar___
4597945410 break;
4598045411 }
45981- case 18446744073709549596LLU: // 99999999ea'''''''''''''''
45412+ case 18446744073709549612LLU: // 99999999eq'''''''''''''''
4598245413 {
4598345414 fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
4598445415 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45987,7 +45418,7 @@
4598745418 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4598845419 }
4598945420 // ACCUMULATE ARGUMENTS - END
45990- uint64_t return_to = 18446744073709549595LLU;
45421+ uint64_t return_to = 18446744073709549611LLU;
4599145422 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4599245423 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4599345424 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45996,7 +45427,7 @@
4599645427 state.addr = 839519665163075584LLU; // skip______
4599745428 break;
4599845429 }
45999- case 18446744073709549595LLU: // 99999999e$'''''''''''''''
45430+ case 18446744073709549611LLU: // 99999999ep'''''''''''''''
4600045431 {
4600145432 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4600245433 // variable resdest___ single____ goes out of scope
@@ -46007,7 +45438,7 @@
4600745438 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4600845439 }
4600945440 // ACCUMULATE ARGUMENTS - END
46010- uint64_t return_to = 18446744073709549594LLU;
45441+ uint64_t return_to = 18446744073709549610LLU;
4601145442 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4601245443 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4601345444 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46016,23 +45447,23 @@
4601645447 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4601745448 break;
4601845449 }
46019- case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
45450+ case 18446744073709549610LLU: // 99999999eo'''''''''''''''
4602045451 {
4602145452 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
46022- state.addr = 18446744073709549601LLU; // 99999999ef'''''''''''''''
45453+ state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
4602345454 break;
4602445455 }
46025- case 18446744073709549602LLU: // 99999999eg'''''''''''''''
45456+ case 18446744073709549618LLU: // 99999999ew'''''''''''''''
4602645457 {
46027- state.addr = 18446744073709549601LLU; // 99999999ef'''''''''''''''
45458+ state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
4602845459 break;
4602945460 }
46030- case 18446744073709549601LLU: // 99999999ef'''''''''''''''
45461+ case 18446744073709549617LLU: // 99999999ev'''''''''''''''
4603145462 {
46032- state.addr = 18446744073709549611LLU; // 99999999ep'''''''''''''''
45463+ state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
4603345464 break;
4603445465 }
46035- case 18446744073709549611LLU: // 99999999ep'''''''''''''''
45466+ case 18446744073709549627LLU: // 99999999e5'''''''''''''''
4603645467 {
4603745468 // variable u64 sym_______ goes out of scope
4603845469 // emitted destructur for type u64
@@ -46091,11 +45522,11 @@
4609145522 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4609245523 }
4609345524 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46094- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549593LLU : 18446744073709549592LLU;
45525+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549609LLU : 18446744073709549608LLU;
4609545526 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4609645527 break;
4609745528 }
46098- case 18446744073709549593LLU: // 99999999eY'''''''''''''''
45529+ case 18446744073709549609LLU: // 99999999en'''''''''''''''
4609945530 {
4610045531 {
4610145532 uint64_t arg = 0;
@@ -46122,7 +45553,7 @@
4612245553 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4612345554 }
4612445555 // ACCUMULATE ARGUMENTS - END
46125- uint64_t return_to = 18446744073709549590LLU;
45556+ uint64_t return_to = 18446744073709549606LLU;
4612645557 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4612745558 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4612845559 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46131,7 +45562,7 @@
4613145562 state.addr = 861504796319285248LLU; // typeu64___
4613245563 break;
4613345564 }
46134- case 18446744073709549590LLU: // 99999999eV'''''''''''''''
45565+ case 18446744073709549606LLU: // 99999999ek'''''''''''''''
4613545566 {
4613645567 {
4613745568 uint64_t arg = 0;
@@ -46156,7 +45587,7 @@
4615645587 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4615745588 }
4615845589 // ACCUMULATE ARGUMENTS - END
46159- uint64_t return_to = 18446744073709549588LLU;
45590+ uint64_t return_to = 18446744073709549604LLU;
4616045591 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4616145592 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4616245593 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46165,7 +45596,7 @@
4616545596 state.addr = 861504796319285248LLU; // typeu64___
4616645597 break;
4616745598 }
46168- case 18446744073709549588LLU: // 99999999eT'''''''''''''''
45599+ case 18446744073709549604LLU: // 99999999ei'''''''''''''''
4616945600 {
4617045601 {
4617145602 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -46185,7 +45616,7 @@
4618545616 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4618645617 }
4618745618 // ACCUMULATE ARGUMENTS - END
46188- uint64_t return_to = 18446744073709549589LLU;
45619+ uint64_t return_to = 18446744073709549605LLU;
4618945620 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4619045621 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4619145622 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46194,7 +45625,7 @@
4619445625 state.addr = 819859607768530944LLU; // resdest___
4619545626 break;
4619645627 }
46197- case 18446744073709549589LLU: // 99999999eU'''''''''''''''
45628+ case 18446744073709549605LLU: // 99999999ej'''''''''''''''
4619845629 {
4619945630 // ACCUMULATE ARGUMENTS - BEGIN
4620045631 {
@@ -46214,7 +45645,7 @@
4621445645 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4621545646 }
4621645647 // ACCUMULATE ARGUMENTS - END
46217- uint64_t return_to = 18446744073709549587LLU;
45648+ uint64_t return_to = 18446744073709549603LLU;
4621845649 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4621945650 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4622045651 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46223,7 +45654,7 @@
4622345654 state.addr = 819857494882385920LLU; // res_u64___
4622445655 break;
4622545656 }
46226- case 18446744073709549587LLU: // 99999999eS'''''''''''''''
45657+ case 18446744073709549603LLU: // 99999999eh'''''''''''''''
4622745658 {
4622845659 // ACCUMULATE ARGUMENTS - BEGIN
4622945660 {
@@ -46231,7 +45662,7 @@
4623145662 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4623245663 }
4623345664 // ACCUMULATE ARGUMENTS - END
46234- uint64_t return_to = 18446744073709549586LLU;
45665+ uint64_t return_to = 18446744073709549602LLU;
4623545666 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4623645667 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4623745668 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46240,7 +45671,7 @@
4624045671 state.addr = 839519665163075584LLU; // skip______
4624145672 break;
4624245673 }
46243- case 18446744073709549586LLU: // 99999999eR'''''''''''''''
45674+ case 18446744073709549602LLU: // 99999999eg'''''''''''''''
4624445675 {
4624545676 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4624645677 fprintf(stdout, "%s", "\n ");
@@ -46266,7 +45697,7 @@
4626645697 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4626745698 }
4626845699 // ACCUMULATE ARGUMENTS - END
46269- uint64_t return_to = 18446744073709549585LLU;
45700+ uint64_t return_to = 18446744073709549601LLU;
4627045701 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4627145702 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4627245703 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46275,7 +45706,7 @@
4627545706 state.addr = 587881357514113024LLU; // emitpar___
4627645707 break;
4627745708 }
46278- case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
45709+ case 18446744073709549601LLU: // 99999999ef'''''''''''''''
4627945710 {
4628045711 fprintf(stdout, "%s", " = ~");
4628145712 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46284,7 +45715,7 @@
4628445715 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4628545716 }
4628645717 // ACCUMULATE ARGUMENTS - END
46287- uint64_t return_to = 18446744073709549584LLU;
45718+ uint64_t return_to = 18446744073709549600LLU;
4628845719 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4628945720 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4629045721 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46293,7 +45724,7 @@
4629345724 state.addr = 839519665163075584LLU; // skip______
4629445725 break;
4629545726 }
46296- case 18446744073709549584LLU: // 99999999eP'''''''''''''''
45727+ case 18446744073709549600LLU: // 99999999ee'''''''''''''''
4629745728 {
4629845729
4629945730 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -46315,7 +45746,7 @@
4631545746 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4631645747 }
4631745748 // ACCUMULATE ARGUMENTS - END
46318- uint64_t return_to = 18446744073709549583LLU;
45749+ uint64_t return_to = 18446744073709549599LLU;
4631945750 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4632045751 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4632145752 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46324,7 +45755,7 @@
4632445755 state.addr = 23446349213393492LLU; // ASSERTINIT
4632545756 break;
4632645757 }
46327- case 18446744073709549583LLU: // 99999999eO'''''''''''''''
45758+ case 18446744073709549599LLU: // 99999999ed'''''''''''''''
4632845759 {
4632945760 {
4633045761 uint64_t arg = 0;
@@ -46403,7 +45834,7 @@
4640345834 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4640445835 }
4640545836 // ACCUMULATE ARGUMENTS - END
46406- uint64_t return_to = 18446744073709549582LLU;
45837+ uint64_t return_to = 18446744073709549598LLU;
4640745838 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4640845839 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4640945840 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46412,7 +45843,7 @@
4641245843 state.addr = 293363126232490310LLU; // PROCVARREF
4641345844 break;
4641445845 }
46415- case 18446744073709549582LLU: // 99999999eN'''''''''''''''
45846+ case 18446744073709549598LLU: // 99999999ec'''''''''''''''
4641645847 {
4641745848 // variable u64 initialize goes out of scope
4641845849 // emitted destructur for type u64
@@ -46433,7 +45864,7 @@
4643345864 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4643445865 }
4643545866 // ACCUMULATE ARGUMENTS - END
46436- uint64_t return_to = 18446744073709549581LLU;
45867+ uint64_t return_to = 18446744073709549597LLU;
4643745868 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4643845869 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4643945870 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46442,7 +45873,7 @@
4644245873 state.addr = 517555565476695680LLU; // assertu64_
4644345874 break;
4644445875 }
46445- case 18446744073709549581LLU: // 99999999eM'''''''''''''''
45876+ case 18446744073709549597LLU: // 99999999eb'''''''''''''''
4644645877 {
4644745878 // ACCUMULATE ARGUMENTS - BEGIN
4644845879 {
@@ -46450,7 +45881,7 @@
4645045881 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4645145882 }
4645245883 // ACCUMULATE ARGUMENTS - END
46453- uint64_t return_to = 18446744073709549580LLU;
45884+ uint64_t return_to = 18446744073709549596LLU;
4645445885 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4645545886 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4645645887 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46459,7 +45890,7 @@
4645945890 state.addr = 839519665163075584LLU; // skip______
4646045891 break;
4646145892 }
46462- case 18446744073709549580LLU: // 99999999eL'''''''''''''''
45893+ case 18446744073709549596LLU: // 99999999ea'''''''''''''''
4646345894 {
4646445895 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4646545896 fprintf(stdout, "%s", ";");
@@ -46471,7 +45902,7 @@
4647145902 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4647245903 }
4647345904 // ACCUMULATE ARGUMENTS - END
46474- uint64_t return_to = 18446744073709549579LLU;
45905+ uint64_t return_to = 18446744073709549595LLU;
4647545906 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4647645907 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4647745908 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46480,7 +45911,7 @@
4648045911 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4648145912 break;
4648245913 }
46483- case 18446744073709549579LLU: // 99999999eK'''''''''''''''
45914+ case 18446744073709549595LLU: // 99999999e$'''''''''''''''
4648445915 {
4648545916 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4648645917 // variable type______ type______ goes out of scope
@@ -46491,7 +45922,7 @@
4649145922 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4649245923 }
4649345924 // ACCUMULATE ARGUMENTS - END
46494- uint64_t return_to = 18446744073709549578LLU;
45925+ uint64_t return_to = 18446744073709549594LLU;
4649545926 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4649645927 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4649745928 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46500,7 +45931,7 @@
4650045931 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4650145932 break;
4650245933 }
46503- case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
45934+ case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
4650445935 {
4650545936 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4650645937 // variable u64 mutable___ goes out of scope
@@ -46512,10 +45943,10 @@
4651245943 // variable u64 id________ goes out of scope
4651345944 // emitted destructur for type u64
4651445945 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
46515- state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
45946+ state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
4651645947 break;
4651745948 }
46518- case 18446744073709549592LLU: // 99999999eX'''''''''''''''
45949+ case 18446744073709549608LLU: // 99999999em'''''''''''''''
4651945950 {
4652045951
4652145952 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750618996096630784;
@@ -46526,11 +45957,11 @@
4652645957 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4652745958 }
4652845959 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46529- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549577LLU : 18446744073709549576LLU;
45960+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549593LLU : 18446744073709549592LLU;
4653045961 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4653145962 break;
4653245963 }
46533- case 18446744073709549577LLU: // 99999999eI'''''''''''''''
45964+ case 18446744073709549593LLU: // 99999999eY'''''''''''''''
4653445965 {
4653545966 {
4653645967 uint64_t arg = 0;
@@ -46557,7 +45988,7 @@
4655745988 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4655845989 }
4655945990 // ACCUMULATE ARGUMENTS - END
46560- uint64_t return_to = 18446744073709549574LLU;
45991+ uint64_t return_to = 18446744073709549590LLU;
4656145992 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4656245993 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4656345994 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46566,7 +45997,7 @@
4656645997 state.addr = 861504796319285248LLU; // typeu64___
4656745998 break;
4656845999 }
46569- case 18446744073709549574LLU: // 99999999eF'''''''''''''''
46000+ case 18446744073709549590LLU: // 99999999eV'''''''''''''''
4657046001 {
4657146002 {
4657246003 uint64_t arg = 0;
@@ -46591,7 +46022,7 @@
4659146022 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4659246023 }
4659346024 // ACCUMULATE ARGUMENTS - END
46594- uint64_t return_to = 18446744073709549572LLU;
46025+ uint64_t return_to = 18446744073709549588LLU;
4659546026 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4659646027 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4659746028 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46600,7 +46031,7 @@
4660046031 state.addr = 861504796319285248LLU; // typeu64___
4660146032 break;
4660246033 }
46603- case 18446744073709549572LLU: // 99999999eD'''''''''''''''
46034+ case 18446744073709549588LLU: // 99999999eT'''''''''''''''
4660446035 {
4660546036 {
4660646037 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -46620,7 +46051,7 @@
4662046051 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4662146052 }
4662246053 // ACCUMULATE ARGUMENTS - END
46623- uint64_t return_to = 18446744073709549573LLU;
46054+ uint64_t return_to = 18446744073709549589LLU;
4662446055 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4662546056 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4662646057 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46629,7 +46060,7 @@
4662946060 state.addr = 819859607768530944LLU; // resdest___
4663046061 break;
4663146062 }
46632- case 18446744073709549573LLU: // 99999999eE'''''''''''''''
46063+ case 18446744073709549589LLU: // 99999999eU'''''''''''''''
4663346064 {
4663446065 // ACCUMULATE ARGUMENTS - BEGIN
4663546066 {
@@ -46649,7 +46080,7 @@
4664946080 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4665046081 }
4665146082 // ACCUMULATE ARGUMENTS - END
46652- uint64_t return_to = 18446744073709549571LLU;
46083+ uint64_t return_to = 18446744073709549587LLU;
4665346084 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4665446085 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4665546086 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46658,7 +46089,7 @@
4665846089 state.addr = 819857494882385920LLU; // res_u64___
4665946090 break;
4666046091 }
46661- case 18446744073709549571LLU: // 99999999eC'''''''''''''''
46092+ case 18446744073709549587LLU: // 99999999eS'''''''''''''''
4666246093 {
4666346094 // ACCUMULATE ARGUMENTS - BEGIN
4666446095 {
@@ -46666,7 +46097,7 @@
4666646097 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4666746098 }
4666846099 // ACCUMULATE ARGUMENTS - END
46669- uint64_t return_to = 18446744073709549570LLU;
46100+ uint64_t return_to = 18446744073709549586LLU;
4667046101 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4667146102 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4667246103 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46675,7 +46106,7 @@
4667546106 state.addr = 839519665163075584LLU; // skip______
4667646107 break;
4667746108 }
46678- case 18446744073709549570LLU: // 99999999eB'''''''''''''''
46109+ case 18446744073709549586LLU: // 99999999eR'''''''''''''''
4667946110 {
4668046111 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4668146112 fprintf(stdout, "%s", "\n ");
@@ -46701,7 +46132,7 @@
4670146132 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4670246133 }
4670346134 // ACCUMULATE ARGUMENTS - END
46704- uint64_t return_to = 18446744073709549569LLU;
46135+ uint64_t return_to = 18446744073709549585LLU;
4670546136 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4670646137 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4670746138 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46710,7 +46141,7 @@
4671046141 state.addr = 587881357514113024LLU; // emitpar___
4671146142 break;
4671246143 }
46713- case 18446744073709549569LLU: // 99999999eA'''''''''''''''
46144+ case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
4671446145 {
4671546146 fprintf(stdout, "%s", " = !");
4671646147 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46719,7 +46150,7 @@
4671946150 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4672046151 }
4672146152 // ACCUMULATE ARGUMENTS - END
46722- uint64_t return_to = 18446744073709549568LLU;
46153+ uint64_t return_to = 18446744073709549584LLU;
4672346154 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4672446155 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4672546156 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46728,7 +46159,7 @@
4672846159 state.addr = 839519665163075584LLU; // skip______
4672946160 break;
4673046161 }
46731- case 18446744073709549568LLU: // 99999999e_'''''''''''''''
46162+ case 18446744073709549584LLU: // 99999999eP'''''''''''''''
4673246163 {
4673346164
4673446165 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -46750,7 +46181,7 @@
4675046181 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4675146182 }
4675246183 // ACCUMULATE ARGUMENTS - END
46753- uint64_t return_to = 18446744073709549567LLU;
46184+ uint64_t return_to = 18446744073709549583LLU;
4675446185 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4675546186 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4675646187 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46759,7 +46190,7 @@
4675946190 state.addr = 23446349213393492LLU; // ASSERTINIT
4676046191 break;
4676146192 }
46762- case 18446744073709549567LLU: // 99999999d9'''''''''''''''
46193+ case 18446744073709549583LLU: // 99999999eO'''''''''''''''
4676346194 {
4676446195 {
4676546196 uint64_t arg = 0;
@@ -46838,7 +46269,7 @@
4683846269 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4683946270 }
4684046271 // ACCUMULATE ARGUMENTS - END
46841- uint64_t return_to = 18446744073709549566LLU;
46272+ uint64_t return_to = 18446744073709549582LLU;
4684246273 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4684346274 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4684446275 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46847,7 +46278,7 @@
4684746278 state.addr = 293363126232490310LLU; // PROCVARREF
4684846279 break;
4684946280 }
46850- case 18446744073709549566LLU: // 99999999d8'''''''''''''''
46281+ case 18446744073709549582LLU: // 99999999eN'''''''''''''''
4685146282 {
4685246283 // variable u64 initialize goes out of scope
4685346284 // emitted destructur for type u64
@@ -46868,7 +46299,7 @@
4686846299 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4686946300 }
4687046301 // ACCUMULATE ARGUMENTS - END
46871- uint64_t return_to = 18446744073709549565LLU;
46302+ uint64_t return_to = 18446744073709549581LLU;
4687246303 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4687346304 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4687446305 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46877,7 +46308,7 @@
4687746308 state.addr = 517555565476695680LLU; // assertu64_
4687846309 break;
4687946310 }
46880- case 18446744073709549565LLU: // 99999999d7'''''''''''''''
46311+ case 18446744073709549581LLU: // 99999999eM'''''''''''''''
4688146312 {
4688246313 // ACCUMULATE ARGUMENTS - BEGIN
4688346314 {
@@ -46885,7 +46316,7 @@
4688546316 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4688646317 }
4688746318 // ACCUMULATE ARGUMENTS - END
46888- uint64_t return_to = 18446744073709549564LLU;
46319+ uint64_t return_to = 18446744073709549580LLU;
4688946320 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4689046321 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4689146322 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46894,7 +46325,7 @@
4689446325 state.addr = 839519665163075584LLU; // skip______
4689546326 break;
4689646327 }
46897- case 18446744073709549564LLU: // 99999999d6'''''''''''''''
46328+ case 18446744073709549580LLU: // 99999999eL'''''''''''''''
4689846329 {
4689946330 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4690046331 fprintf(stdout, "%s", ";");
@@ -46906,7 +46337,7 @@
4690646337 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4690746338 }
4690846339 // ACCUMULATE ARGUMENTS - END
46909- uint64_t return_to = 18446744073709549563LLU;
46340+ uint64_t return_to = 18446744073709549579LLU;
4691046341 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4691146342 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4691246343 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46915,7 +46346,7 @@
4691546346 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4691646347 break;
4691746348 }
46918- case 18446744073709549563LLU: // 99999999d5'''''''''''''''
46349+ case 18446744073709549579LLU: // 99999999eK'''''''''''''''
4691946350 {
4692046351 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4692146352 // variable type______ type______ goes out of scope
@@ -46926,7 +46357,7 @@
4692646357 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4692746358 }
4692846359 // ACCUMULATE ARGUMENTS - END
46929- uint64_t return_to = 18446744073709549562LLU;
46360+ uint64_t return_to = 18446744073709549578LLU;
4693046361 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4693146362 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4693246363 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46935,7 +46366,7 @@
4693546366 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4693646367 break;
4693746368 }
46938- case 18446744073709549562LLU: // 99999999d4'''''''''''''''
46369+ case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
4693946370 {
4694046371 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4694146372 // variable u64 mutable___ goes out of scope
@@ -46947,10 +46378,10 @@
4694746378 // variable u64 id________ goes out of scope
4694846379 // emitted destructur for type u64
4694946380 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
46950- state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
46381+ state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
4695146382 break;
4695246383 }
46953- case 18446744073709549576LLU: // 99999999eH'''''''''''''''
46384+ case 18446744073709549592LLU: // 99999999eX'''''''''''''''
4695446385 {
4695546386
4695646387 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543416397824;
@@ -46961,11 +46392,11 @@
4696146392 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4696246393 }
4696346394 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46964- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549561LLU : 18446744073709549560LLU;
46395+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549577LLU : 18446744073709549576LLU;
4696546396 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4696646397 break;
4696746398 }
46968- case 18446744073709549561LLU: // 99999999d3'''''''''''''''
46399+ case 18446744073709549577LLU: // 99999999eI'''''''''''''''
4696946400 {
4697046401 {
4697146402 uint64_t arg = 0;
@@ -46992,7 +46423,7 @@
4699246423 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4699346424 }
4699446425 // ACCUMULATE ARGUMENTS - END
46995- uint64_t return_to = 18446744073709549558LLU;
46426+ uint64_t return_to = 18446744073709549574LLU;
4699646427 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4699746428 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4699846429 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47001,7 +46432,7 @@
4700146432 state.addr = 861504796319285248LLU; // typeu64___
4700246433 break;
4700346434 }
47004- case 18446744073709549558LLU: // 99999999d0'''''''''''''''
46435+ case 18446744073709549574LLU: // 99999999eF'''''''''''''''
4700546436 {
4700646437 {
4700746438 uint64_t arg = 0;
@@ -47026,7 +46457,7 @@
4702646457 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4702746458 }
4702846459 // ACCUMULATE ARGUMENTS - END
47029- uint64_t return_to = 18446744073709549556LLU;
46460+ uint64_t return_to = 18446744073709549572LLU;
4703046461 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4703146462 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4703246463 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47035,7 +46466,7 @@
4703546466 state.addr = 861504796319285248LLU; // typeu64___
4703646467 break;
4703746468 }
47038- case 18446744073709549556LLU: // 99999999dy'''''''''''''''
46469+ case 18446744073709549572LLU: // 99999999eD'''''''''''''''
4703946470 {
4704046471 {
4704146472 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -47055,7 +46486,7 @@
4705546486 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4705646487 }
4705746488 // ACCUMULATE ARGUMENTS - END
47058- uint64_t return_to = 18446744073709549557LLU;
46489+ uint64_t return_to = 18446744073709549573LLU;
4705946490 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4706046491 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4706146492 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47064,7 +46495,7 @@
4706446495 state.addr = 819859607768530944LLU; // resdest___
4706546496 break;
4706646497 }
47067- case 18446744073709549557LLU: // 99999999dz'''''''''''''''
46498+ case 18446744073709549573LLU: // 99999999eE'''''''''''''''
4706846499 {
4706946500 // ACCUMULATE ARGUMENTS - BEGIN
4707046501 {
@@ -47084,7 +46515,7 @@
4708446515 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4708546516 }
4708646517 // ACCUMULATE ARGUMENTS - END
47087- uint64_t return_to = 18446744073709549555LLU;
46518+ uint64_t return_to = 18446744073709549571LLU;
4708846519 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4708946520 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4709046521 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47093,7 +46524,7 @@
4709346524 state.addr = 819857494882385920LLU; // res_u64___
4709446525 break;
4709546526 }
47096- case 18446744073709549555LLU: // 99999999dx'''''''''''''''
46527+ case 18446744073709549571LLU: // 99999999eC'''''''''''''''
4709746528 {
4709846529 // ACCUMULATE ARGUMENTS - BEGIN
4709946530 {
@@ -47101,7 +46532,7 @@
4710146532 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4710246533 }
4710346534 // ACCUMULATE ARGUMENTS - END
47104- uint64_t return_to = 18446744073709549554LLU;
46535+ uint64_t return_to = 18446744073709549570LLU;
4710546536 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4710646537 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4710746538 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47110,7 +46541,7 @@
4711046541 state.addr = 839519665163075584LLU; // skip______
4711146542 break;
4711246543 }
47113- case 18446744073709549554LLU: // 99999999dw'''''''''''''''
46544+ case 18446744073709549570LLU: // 99999999eB'''''''''''''''
4711446545 {
4711546546 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4711646547 fprintf(stdout, "%s", "\n ");
@@ -47136,7 +46567,7 @@
4713646567 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4713746568 }
4713846569 // ACCUMULATE ARGUMENTS - END
47139- uint64_t return_to = 18446744073709549553LLU;
46570+ uint64_t return_to = 18446744073709549569LLU;
4714046571 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4714146572 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4714246573 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47145,7 +46576,7 @@
4714546576 state.addr = 587881357514113024LLU; // emitpar___
4714646577 break;
4714746578 }
47148- case 18446744073709549553LLU: // 99999999dv'''''''''''''''
46579+ case 18446744073709549569LLU: // 99999999eA'''''''''''''''
4714946580 {
4715046581 fprintf(stdout, "%s", " = parseid(&");
4715146582 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47154,7 +46585,7 @@
4715446585 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4715546586 }
4715646587 // ACCUMULATE ARGUMENTS - END
47157- uint64_t return_to = 18446744073709549552LLU;
46588+ uint64_t return_to = 18446744073709549568LLU;
4715846589 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4715946590 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4716046591 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47163,7 +46594,7 @@
4716346594 state.addr = 839519665163075584LLU; // skip______
4716446595 break;
4716546596 }
47166- case 18446744073709549552LLU: // 99999999du'''''''''''''''
46597+ case 18446744073709549568LLU: // 99999999e_'''''''''''''''
4716746598 {
4716846599
4716946600 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -47185,7 +46616,7 @@
4718546616 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4718646617 }
4718746618 // ACCUMULATE ARGUMENTS - END
47188- uint64_t return_to = 18446744073709549551LLU;
46619+ uint64_t return_to = 18446744073709549567LLU;
4718946620 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4719046621 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4719146622 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47194,7 +46625,7 @@
4719446625 state.addr = 23446349213393492LLU; // ASSERTINIT
4719546626 break;
4719646627 }
47197- case 18446744073709549551LLU: // 99999999dt'''''''''''''''
46628+ case 18446744073709549567LLU: // 99999999d9'''''''''''''''
4719846629 {
4719946630 {
4720046631 uint64_t arg = 0;
@@ -47273,7 +46704,7 @@
4727346704 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4727446705 }
4727546706 // ACCUMULATE ARGUMENTS - END
47276- uint64_t return_to = 18446744073709549550LLU;
46707+ uint64_t return_to = 18446744073709549566LLU;
4727746708 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4727846709 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4727946710 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47282,7 +46713,7 @@
4728246713 state.addr = 293363126232490310LLU; // PROCVARREF
4728346714 break;
4728446715 }
47285- case 18446744073709549550LLU: // 99999999ds'''''''''''''''
46716+ case 18446744073709549566LLU: // 99999999d8'''''''''''''''
4728646717 {
4728746718 // variable u64 initialize goes out of scope
4728846719 // emitted destructur for type u64
@@ -47303,7 +46734,7 @@
4730346734 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4730446735 }
4730546736 // ACCUMULATE ARGUMENTS - END
47306- uint64_t return_to = 18446744073709549549LLU;
46737+ uint64_t return_to = 18446744073709549565LLU;
4730746738 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4730846739 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4730946740 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47312,7 +46743,7 @@
4731246743 state.addr = 517555565476695680LLU; // assertu64_
4731346744 break;
4731446745 }
47315- case 18446744073709549549LLU: // 99999999dr'''''''''''''''
46746+ case 18446744073709549565LLU: // 99999999d7'''''''''''''''
4731646747 {
4731746748 fprintf(stdout, "%s", ");");
4731846749 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47321,7 +46752,7 @@
4732146752 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4732246753 }
4732346754 // ACCUMULATE ARGUMENTS - END
47324- uint64_t return_to = 18446744073709549548LLU;
46755+ uint64_t return_to = 18446744073709549564LLU;
4732546756 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4732646757 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4732746758 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47330,7 +46761,7 @@
4733046761 state.addr = 839519665163075584LLU; // skip______
4733146762 break;
4733246763 }
47333- case 18446744073709549548LLU: // 99999999dq'''''''''''''''
46764+ case 18446744073709549564LLU: // 99999999d6'''''''''''''''
4733446765 {
4733546766 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4733646767 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47343,7 +46774,7 @@
4734346774 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4734446775 }
4734546776 // ACCUMULATE ARGUMENTS - END
47346- uint64_t return_to = 18446744073709549547LLU;
46777+ uint64_t return_to = 18446744073709549563LLU;
4734746778 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4734846779 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4734946780 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47352,7 +46783,7 @@
4735246783 state.addr = 517555565476695680LLU; // assertu64_
4735346784 break;
4735446785 }
47355- case 18446744073709549547LLU: // 99999999dp'''''''''''''''
46786+ case 18446744073709549563LLU: // 99999999d5'''''''''''''''
4735646787 {
4735746788 {
4735846789 uint64_t arg = 0;
@@ -47381,7 +46812,7 @@
4738146812 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4738246813 }
4738346814 // ACCUMULATE ARGUMENTS - END
47384- uint64_t return_to = 18446744073709549546LLU;
46815+ uint64_t return_to = 18446744073709549562LLU;
4738546816 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4738646817 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4738746818 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47390,7 +46821,7 @@
4739046821 state.addr = 734295421765213120LLU; // mutassert_
4739146822 break;
4739246823 }
47393- case 18446744073709549546LLU: // 99999999do'''''''''''''''
46824+ case 18446744073709549562LLU: // 99999999d4'''''''''''''''
4739446825 {
4739546826 // variable u64 parnr_____ goes out of scope
4739646827 // emitted destructur for type u64
@@ -47403,7 +46834,7 @@
4740346834 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4740446835 }
4740546836 // ACCUMULATE ARGUMENTS - END
47406- uint64_t return_to = 18446744073709549545LLU;
46837+ uint64_t return_to = 18446744073709549561LLU;
4740746838 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4740846839 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4740946840 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47412,7 +46843,7 @@
4741246843 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4741346844 break;
4741446845 }
47415- case 18446744073709549545LLU: // 99999999dn'''''''''''''''
46846+ case 18446744073709549561LLU: // 99999999d3'''''''''''''''
4741646847 {
4741746848 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4741846849 // variable type______ type______ goes out of scope
@@ -47423,7 +46854,7 @@
4742346854 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4742446855 }
4742546856 // ACCUMULATE ARGUMENTS - END
47426- uint64_t return_to = 18446744073709549544LLU;
46857+ uint64_t return_to = 18446744073709549560LLU;
4742746858 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4742846859 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4742946860 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47432,7 +46863,7 @@
4743246863 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4743346864 break;
4743446865 }
47435- case 18446744073709549544LLU: // 99999999dm'''''''''''''''
46866+ case 18446744073709549560LLU: // 99999999d2'''''''''''''''
4743646867 {
4743746868 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4743846869 // variable u64 mutable___ goes out of scope
@@ -47444,10 +46875,10 @@
4744446875 // variable u64 id________ goes out of scope
4744546876 // emitted destructur for type u64
4744646877 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
47447- state.addr = 18446744073709549559LLU; // 99999999d1'''''''''''''''
46878+ state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
4744846879 break;
4744946880 }
47450- case 18446744073709549560LLU: // 99999999d2'''''''''''''''
46881+ case 18446744073709549576LLU: // 99999999eH'''''''''''''''
4745146882 {
4745246883
4745346884 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543503953920;
@@ -47458,11 +46889,11 @@
4745846889 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4745946890 }
4746046891 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47461- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549543LLU : 18446744073709549542LLU;
46892+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549559LLU : 18446744073709549558LLU;
4746246893 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4746346894 break;
4746446895 }
47465- case 18446744073709549543LLU: // 99999999dl'''''''''''''''
46896+ case 18446744073709549559LLU: // 99999999d1'''''''''''''''
4746646897 {
4746746898 {
4746846899 uint64_t arg = 0;
@@ -47489,7 +46920,7 @@
4748946920 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4749046921 }
4749146922 // ACCUMULATE ARGUMENTS - END
47492- uint64_t return_to = 18446744073709549540LLU;
46923+ uint64_t return_to = 18446744073709549556LLU;
4749346924 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4749446925 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4749546926 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47498,7 +46929,7 @@
4749846929 state.addr = 861504796319285248LLU; // typeu64___
4749946930 break;
4750046931 }
47501- case 18446744073709549540LLU: // 99999999di'''''''''''''''
46932+ case 18446744073709549556LLU: // 99999999dy'''''''''''''''
4750246933 {
4750346934 {
4750446935 uint64_t arg = 0;
@@ -47523,7 +46954,7 @@
4752346954 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4752446955 }
4752546956 // ACCUMULATE ARGUMENTS - END
47526- uint64_t return_to = 18446744073709549538LLU;
46957+ uint64_t return_to = 18446744073709549554LLU;
4752746958 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4752846959 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4752946960 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47532,7 +46963,7 @@
4753246963 state.addr = 861504796319285248LLU; // typeu64___
4753346964 break;
4753446965 }
47535- case 18446744073709549538LLU: // 99999999dg'''''''''''''''
46966+ case 18446744073709549554LLU: // 99999999dw'''''''''''''''
4753646967 {
4753746968 {
4753846969 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -47552,7 +46983,7 @@
4755246983 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4755346984 }
4755446985 // ACCUMULATE ARGUMENTS - END
47555- uint64_t return_to = 18446744073709549539LLU;
46986+ uint64_t return_to = 18446744073709549555LLU;
4755646987 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4755746988 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4755846989 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47561,7 +46992,7 @@
4756146992 state.addr = 819859607768530944LLU; // resdest___
4756246993 break;
4756346994 }
47564- case 18446744073709549539LLU: // 99999999dh'''''''''''''''
46995+ case 18446744073709549555LLU: // 99999999dx'''''''''''''''
4756546996 {
4756646997 // ACCUMULATE ARGUMENTS - BEGIN
4756746998 {
@@ -47581,7 +47012,7 @@
4758147012 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4758247013 }
4758347014 // ACCUMULATE ARGUMENTS - END
47584- uint64_t return_to = 18446744073709549537LLU;
47015+ uint64_t return_to = 18446744073709549553LLU;
4758547016 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4758647017 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4758747018 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47590,7 +47021,7 @@
4759047021 state.addr = 819857494882385920LLU; // res_u64___
4759147022 break;
4759247023 }
47593- case 18446744073709549537LLU: // 99999999df'''''''''''''''
47024+ case 18446744073709549553LLU: // 99999999dv'''''''''''''''
4759447025 {
4759547026 // ACCUMULATE ARGUMENTS - BEGIN
4759647027 {
@@ -47598,7 +47029,7 @@
4759847029 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4759947030 }
4760047031 // ACCUMULATE ARGUMENTS - END
47601- uint64_t return_to = 18446744073709549536LLU;
47032+ uint64_t return_to = 18446744073709549552LLU;
4760247033 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4760347034 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4760447035 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47607,7 +47038,7 @@
4760747038 state.addr = 839519665163075584LLU; // skip______
4760847039 break;
4760947040 }
47610- case 18446744073709549536LLU: // 99999999de'''''''''''''''
47041+ case 18446744073709549552LLU: // 99999999du'''''''''''''''
4761147042 {
4761247043 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4761347044 fprintf(stdout, "%s", "\n ");
@@ -47633,7 +47064,7 @@
4763347064 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4763447065 }
4763547066 // ACCUMULATE ARGUMENTS - END
47636- uint64_t return_to = 18446744073709549535LLU;
47067+ uint64_t return_to = 18446744073709549551LLU;
4763747068 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4763847069 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4763947070 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47642,7 +47073,7 @@
4764247073 state.addr = 587881357514113024LLU; // emitpar___
4764347074 break;
4764447075 }
47645- case 18446744073709549535LLU: // 99999999dd'''''''''''''''
47076+ case 18446744073709549551LLU: // 99999999dt'''''''''''''''
4764647077 {
4764747078 fprintf(stdout, "%s", " = parsenr(&");
4764847079 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47651,7 +47082,7 @@
4765147082 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4765247083 }
4765347084 // ACCUMULATE ARGUMENTS - END
47654- uint64_t return_to = 18446744073709549534LLU;
47085+ uint64_t return_to = 18446744073709549550LLU;
4765547086 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4765647087 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4765747088 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47660,7 +47091,7 @@
4766047091 state.addr = 839519665163075584LLU; // skip______
4766147092 break;
4766247093 }
47663- case 18446744073709549534LLU: // 99999999dc'''''''''''''''
47094+ case 18446744073709549550LLU: // 99999999ds'''''''''''''''
4766447095 {
4766547096
4766647097 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -47682,7 +47113,7 @@
4768247113 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4768347114 }
4768447115 // ACCUMULATE ARGUMENTS - END
47685- uint64_t return_to = 18446744073709549533LLU;
47116+ uint64_t return_to = 18446744073709549549LLU;
4768647117 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4768747118 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4768847119 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47691,7 +47122,7 @@
4769147122 state.addr = 23446349213393492LLU; // ASSERTINIT
4769247123 break;
4769347124 }
47694- case 18446744073709549533LLU: // 99999999db'''''''''''''''
47125+ case 18446744073709549549LLU: // 99999999dr'''''''''''''''
4769547126 {
4769647127 {
4769747128 uint64_t arg = 0;
@@ -47770,7 +47201,7 @@
4777047201 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4777147202 }
4777247203 // ACCUMULATE ARGUMENTS - END
47773- uint64_t return_to = 18446744073709549532LLU;
47204+ uint64_t return_to = 18446744073709549548LLU;
4777447205 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4777547206 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4777647207 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47779,7 +47210,7 @@
4777947210 state.addr = 293363126232490310LLU; // PROCVARREF
4778047211 break;
4778147212 }
47782- case 18446744073709549532LLU: // 99999999da'''''''''''''''
47213+ case 18446744073709549548LLU: // 99999999dq'''''''''''''''
4778347214 {
4778447215 // variable u64 initialize goes out of scope
4778547216 // emitted destructur for type u64
@@ -47800,7 +47231,7 @@
4780047231 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4780147232 }
4780247233 // ACCUMULATE ARGUMENTS - END
47803- uint64_t return_to = 18446744073709549531LLU;
47234+ uint64_t return_to = 18446744073709549547LLU;
4780447235 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4780547236 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4780647237 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47809,7 +47240,7 @@
4780947240 state.addr = 517555565476695680LLU; // assertu64_
4781047241 break;
4781147242 }
47812- case 18446744073709549531LLU: // 99999999d$'''''''''''''''
47243+ case 18446744073709549547LLU: // 99999999dp'''''''''''''''
4781347244 {
4781447245 fprintf(stdout, "%s", ");");
4781547246 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47818,7 +47249,7 @@
4781847249 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4781947250 }
4782047251 // ACCUMULATE ARGUMENTS - END
47821- uint64_t return_to = 18446744073709549530LLU;
47252+ uint64_t return_to = 18446744073709549546LLU;
4782247253 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4782347254 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4782447255 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47827,7 +47258,7 @@
4782747258 state.addr = 839519665163075584LLU; // skip______
4782847259 break;
4782947260 }
47830- case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
47261+ case 18446744073709549546LLU: // 99999999do'''''''''''''''
4783147262 {
4783247263 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4783347264 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47840,7 +47271,7 @@
4784047271 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4784147272 }
4784247273 // ACCUMULATE ARGUMENTS - END
47843- uint64_t return_to = 18446744073709549529LLU;
47274+ uint64_t return_to = 18446744073709549545LLU;
4784447275 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4784547276 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4784647277 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47849,7 +47280,7 @@
4784947280 state.addr = 517555565476695680LLU; // assertu64_
4785047281 break;
4785147282 }
47852- case 18446744073709549529LLU: // 99999999dY'''''''''''''''
47283+ case 18446744073709549545LLU: // 99999999dn'''''''''''''''
4785347284 {
4785447285 {
4785547286 uint64_t arg = 0;
@@ -47878,7 +47309,7 @@
4787847309 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4787947310 }
4788047311 // ACCUMULATE ARGUMENTS - END
47881- uint64_t return_to = 18446744073709549528LLU;
47312+ uint64_t return_to = 18446744073709549544LLU;
4788247313 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4788347314 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4788447315 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47887,7 +47318,7 @@
4788747318 state.addr = 734295421765213120LLU; // mutassert_
4788847319 break;
4788947320 }
47890- case 18446744073709549528LLU: // 99999999dX'''''''''''''''
47321+ case 18446744073709549544LLU: // 99999999dm'''''''''''''''
4789147322 {
4789247323 // variable u64 parnr_____ goes out of scope
4789347324 // emitted destructur for type u64
@@ -47900,7 +47331,7 @@
4790047331 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4790147332 }
4790247333 // ACCUMULATE ARGUMENTS - END
47903- uint64_t return_to = 18446744073709549527LLU;
47334+ uint64_t return_to = 18446744073709549543LLU;
4790447335 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4790547336 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4790647337 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47909,7 +47340,7 @@
4790947340 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4791047341 break;
4791147342 }
47912- case 18446744073709549527LLU: // 99999999dW'''''''''''''''
47343+ case 18446744073709549543LLU: // 99999999dl'''''''''''''''
4791347344 {
4791447345 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4791547346 // variable type______ type______ goes out of scope
@@ -47920,7 +47351,7 @@
4792047351 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4792147352 }
4792247353 // ACCUMULATE ARGUMENTS - END
47923- uint64_t return_to = 18446744073709549526LLU;
47354+ uint64_t return_to = 18446744073709549542LLU;
4792447355 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4792547356 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4792647357 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47929,7 +47360,7 @@
4792947360 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4793047361 break;
4793147362 }
47932- case 18446744073709549526LLU: // 99999999dV'''''''''''''''
47363+ case 18446744073709549542LLU: // 99999999dk'''''''''''''''
4793347364 {
4793447365 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4793547366 // variable u64 mutable___ goes out of scope
@@ -47941,10 +47372,10 @@
4794147372 // variable u64 id________ goes out of scope
4794247373 // emitted destructur for type u64
4794347374 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
47944- state.addr = 18446744073709549541LLU; // 99999999dj'''''''''''''''
47375+ state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
4794547376 break;
4794647377 }
47947- case 18446744073709549542LLU: // 99999999dk'''''''''''''''
47378+ case 18446744073709549558LLU: // 99999999d0'''''''''''''''
4794847379 {
4794947380
4795047381 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750596285075554304;
@@ -47955,11 +47386,11 @@
4795547386 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4795647387 }
4795747388 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47958- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549525LLU : 18446744073709549524LLU;
47389+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549541LLU : 18446744073709549540LLU;
4795947390 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4796047391 break;
4796147392 }
47962- case 18446744073709549525LLU: // 99999999dU'''''''''''''''
47393+ case 18446744073709549541LLU: // 99999999dj'''''''''''''''
4796347394 {
4796447395 {
4796547396 uint64_t arg = 0;
@@ -47986,7 +47417,7 @@
4798647417 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4798747418 }
4798847419 // ACCUMULATE ARGUMENTS - END
47989- uint64_t return_to = 18446744073709549522LLU;
47420+ uint64_t return_to = 18446744073709549538LLU;
4799047421 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4799147422 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4799247423 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47995,7 +47426,7 @@
4799547426 state.addr = 861504796319285248LLU; // typeu64___
4799647427 break;
4799747428 }
47998- case 18446744073709549522LLU: // 99999999dR'''''''''''''''
47429+ case 18446744073709549538LLU: // 99999999dg'''''''''''''''
4799947430 {
4800047431 {
4800147432 uint64_t arg = 0;
@@ -48020,7 +47451,7 @@
4802047451 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4802147452 }
4802247453 // ACCUMULATE ARGUMENTS - END
48023- uint64_t return_to = 18446744073709549520LLU;
47454+ uint64_t return_to = 18446744073709549536LLU;
4802447455 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4802547456 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4802647457 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48029,7 +47460,7 @@
4802947460 state.addr = 861504796319285248LLU; // typeu64___
4803047461 break;
4803147462 }
48032- case 18446744073709549520LLU: // 99999999dP'''''''''''''''
47463+ case 18446744073709549536LLU: // 99999999de'''''''''''''''
4803347464 {
4803447465 {
4803547466 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -48049,7 +47480,7 @@
4804947480 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4805047481 }
4805147482 // ACCUMULATE ARGUMENTS - END
48052- uint64_t return_to = 18446744073709549521LLU;
47483+ uint64_t return_to = 18446744073709549537LLU;
4805347484 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4805447485 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4805547486 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48058,7 +47489,7 @@
4805847489 state.addr = 819859607768530944LLU; // resdest___
4805947490 break;
4806047491 }
48061- case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
47492+ case 18446744073709549537LLU: // 99999999df'''''''''''''''
4806247493 {
4806347494 // ACCUMULATE ARGUMENTS - BEGIN
4806447495 {
@@ -48078,7 +47509,7 @@
4807847509 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4807947510 }
4808047511 // ACCUMULATE ARGUMENTS - END
48081- uint64_t return_to = 18446744073709549519LLU;
47512+ uint64_t return_to = 18446744073709549535LLU;
4808247513 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4808347514 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4808447515 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48087,7 +47518,7 @@
4808747518 state.addr = 819857494882385920LLU; // res_u64___
4808847519 break;
4808947520 }
48090- case 18446744073709549519LLU: // 99999999dO'''''''''''''''
47521+ case 18446744073709549535LLU: // 99999999dd'''''''''''''''
4809147522 {
4809247523 // ACCUMULATE ARGUMENTS - BEGIN
4809347524 {
@@ -48095,7 +47526,7 @@
4809547526 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4809647527 }
4809747528 // ACCUMULATE ARGUMENTS - END
48098- uint64_t return_to = 18446744073709549518LLU;
47529+ uint64_t return_to = 18446744073709549534LLU;
4809947530 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4810047531 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4810147532 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48104,7 +47535,7 @@
4810447535 state.addr = 839519665163075584LLU; // skip______
4810547536 break;
4810647537 }
48107- case 18446744073709549518LLU: // 99999999dN'''''''''''''''
47538+ case 18446744073709549534LLU: // 99999999dc'''''''''''''''
4810847539 {
4810947540 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4811047541 fprintf(stdout, "%s", "\n ");
@@ -48130,7 +47561,7 @@
4813047561 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4813147562 }
4813247563 // ACCUMULATE ARGUMENTS - END
48133- uint64_t return_to = 18446744073709549517LLU;
47564+ uint64_t return_to = 18446744073709549533LLU;
4813447565 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4813547566 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4813647567 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48139,7 +47570,7 @@
4813947570 state.addr = 587881357514113024LLU; // emitpar___
4814047571 break;
4814147572 }
48142- case 18446744073709549517LLU: // 99999999dM'''''''''''''''
47573+ case 18446744073709549533LLU: // 99999999db'''''''''''''''
4814347574 {
4814447575 fprintf(stdout, "%s", " = !!");
4814547576 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48148,7 +47579,7 @@
4814847579 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4814947580 }
4815047581 // ACCUMULATE ARGUMENTS - END
48151- uint64_t return_to = 18446744073709549516LLU;
47582+ uint64_t return_to = 18446744073709549532LLU;
4815247583 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4815347584 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4815447585 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48157,7 +47588,7 @@
4815747588 state.addr = 839519665163075584LLU; // skip______
4815847589 break;
4815947590 }
48160- case 18446744073709549516LLU: // 99999999dL'''''''''''''''
47591+ case 18446744073709549532LLU: // 99999999da'''''''''''''''
4816147592 {
4816247593
4816347594 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -48179,7 +47610,7 @@
4817947610 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4818047611 }
4818147612 // ACCUMULATE ARGUMENTS - END
48182- uint64_t return_to = 18446744073709549515LLU;
47613+ uint64_t return_to = 18446744073709549531LLU;
4818347614 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4818447615 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4818547616 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48188,7 +47619,7 @@
4818847619 state.addr = 23446349213393492LLU; // ASSERTINIT
4818947620 break;
4819047621 }
48191- case 18446744073709549515LLU: // 99999999dK'''''''''''''''
47622+ case 18446744073709549531LLU: // 99999999d$'''''''''''''''
4819247623 {
4819347624 {
4819447625 uint64_t arg = 0;
@@ -48267,7 +47698,7 @@
4826747698 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4826847699 }
4826947700 // ACCUMULATE ARGUMENTS - END
48270- uint64_t return_to = 18446744073709549514LLU;
47701+ uint64_t return_to = 18446744073709549530LLU;
4827147702 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4827247703 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4827347704 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48276,7 +47707,7 @@
4827647707 state.addr = 293363126232490310LLU; // PROCVARREF
4827747708 break;
4827847709 }
48279- case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
47710+ case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
4828047711 {
4828147712 // variable u64 initialize goes out of scope
4828247713 // emitted destructur for type u64
@@ -48293,7 +47724,7 @@
4829347724 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4829447725 }
4829547726 // ACCUMULATE ARGUMENTS - END
48296- uint64_t return_to = 18446744073709549513LLU;
47727+ uint64_t return_to = 18446744073709549529LLU;
4829747728 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4829847729 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4829947730 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48302,7 +47733,7 @@
4830247733 state.addr = 839519665163075584LLU; // skip______
4830347734 break;
4830447735 }
48305- case 18446744073709549513LLU: // 99999999dI'''''''''''''''
47736+ case 18446744073709549529LLU: // 99999999dY'''''''''''''''
4830647737 {
4830747738 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4830847739 fprintf(stdout, "%s", ";");
@@ -48314,7 +47745,7 @@
4831447745 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4831547746 }
4831647747 // ACCUMULATE ARGUMENTS - END
48317- uint64_t return_to = 18446744073709549512LLU;
47748+ uint64_t return_to = 18446744073709549528LLU;
4831847749 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4831947750 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4832047751 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48323,7 +47754,7 @@
4832347754 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4832447755 break;
4832547756 }
48326- case 18446744073709549512LLU: // 99999999dH'''''''''''''''
47757+ case 18446744073709549528LLU: // 99999999dX'''''''''''''''
4832747758 {
4832847759 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4832947760 // variable type______ type______ goes out of scope
@@ -48334,7 +47765,7 @@
4833447765 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4833547766 }
4833647767 // ACCUMULATE ARGUMENTS - END
48337- uint64_t return_to = 18446744073709549511LLU;
47768+ uint64_t return_to = 18446744073709549527LLU;
4833847769 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4833947770 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4834047771 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48343,7 +47774,7 @@
4834347774 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4834447775 break;
4834547776 }
48346- case 18446744073709549511LLU: // 99999999dG'''''''''''''''
47777+ case 18446744073709549527LLU: // 99999999dW'''''''''''''''
4834747778 {
4834847779 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4834947780 // variable u64 mutable___ goes out of scope
@@ -48355,10 +47786,10 @@
4835547786 // variable u64 id________ goes out of scope
4835647787 // emitted destructur for type u64
4835747788 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
48358- state.addr = 18446744073709549523LLU; // 99999999dS'''''''''''''''
47789+ state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
4835947790 break;
4836047791 }
48361- case 18446744073709549524LLU: // 99999999dT'''''''''''''''
47792+ case 18446744073709549540LLU: // 99999999di'''''''''''''''
4836247793 {
4836347794
4836447795 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 839030726086098944;
@@ -48369,11 +47800,11 @@
4836947800 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4837047801 }
4837147802 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48372- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549510LLU : 18446744073709549509LLU;
47803+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549526LLU : 18446744073709549525LLU;
4837347804 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4837447805 break;
4837547806 }
48376- case 18446744073709549510LLU: // 99999999dF'''''''''''''''
47807+ case 18446744073709549526LLU: // 99999999dV'''''''''''''''
4837747808 {
4837847809 {
4837947810 uint64_t arg = 0;
@@ -48398,7 +47829,7 @@
4839847829 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4839947830 }
4840047831 // ACCUMULATE ARGUMENTS - END
48401- uint64_t return_to = 18446744073709549506LLU;
47832+ uint64_t return_to = 18446744073709549522LLU;
4840247833 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4840347834 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4840447835 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48407,7 +47838,7 @@
4840747838 state.addr = 861504796319285248LLU; // typeu64___
4840847839 break;
4840947840 }
48410- case 18446744073709549506LLU: // 99999999dB'''''''''''''''
47841+ case 18446744073709549522LLU: // 99999999dR'''''''''''''''
4841147842 {
4841247843 {
4841347844 uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 19*/;
@@ -48427,7 +47858,7 @@
4842747858 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4842847859 }
4842947860 // ACCUMULATE ARGUMENTS - END
48430- uint64_t return_to = 18446744073709549507LLU;
47861+ uint64_t return_to = 18446744073709549523LLU;
4843147862 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4843247863 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4843347864 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48436,7 +47867,7 @@
4843647867 state.addr = 819859607768530944LLU; // resdest___
4843747868 break;
4843847869 }
48439- case 18446744073709549507LLU: // 99999999dC'''''''''''''''
47870+ case 18446744073709549523LLU: // 99999999dS'''''''''''''''
4844047871 {
4844147872 // ACCUMULATE ARGUMENTS - BEGIN
4844247873 {
@@ -48456,7 +47887,7 @@
4845647887 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4845747888 }
4845847889 // ACCUMULATE ARGUMENTS - END
48459- uint64_t return_to = 18446744073709549505LLU;
47890+ uint64_t return_to = 18446744073709549521LLU;
4846047891 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4846147892 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4846247893 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48465,7 +47896,7 @@
4846547896 state.addr = 819857494882385920LLU; // res_u64___
4846647897 break;
4846747898 }
48468- case 18446744073709549505LLU: // 99999999dA'''''''''''''''
47899+ case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
4846947900 {
4847047901 // ACCUMULATE ARGUMENTS - BEGIN
4847147902 {
@@ -48473,7 +47904,7 @@
4847347904 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4847447905 }
4847547906 // ACCUMULATE ARGUMENTS - END
48476- uint64_t return_to = 18446744073709549504LLU;
47907+ uint64_t return_to = 18446744073709549520LLU;
4847747908 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4847847909 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4847947910 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48482,7 +47913,7 @@
4848247913 state.addr = 839519665163075584LLU; // skip______
4848347914 break;
4848447915 }
48485- case 18446744073709549504LLU: // 99999999d_'''''''''''''''
47916+ case 18446744073709549520LLU: // 99999999dP'''''''''''''''
4848647917 {
4848747918 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4848847919 fprintf(stdout, "%s", "\n list_size2(heap.data, &");
@@ -48508,7 +47939,7 @@
4850847939 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4850947940 }
4851047941 // ACCUMULATE ARGUMENTS - END
48511- uint64_t return_to = 18446744073709549503LLU;
47942+ uint64_t return_to = 18446744073709549519LLU;
4851247943 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4851347944 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4851447945 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48517,7 +47948,7 @@
4851747948 state.addr = 587881357514113024LLU; // emitpar___
4851847949 break;
4851947950 }
48520- case 18446744073709549503LLU: // 99999999c9'''''''''''''''
47951+ case 18446744073709549519LLU: // 99999999dO'''''''''''''''
4852147952 {
4852247953 fprintf(stdout, "%s", ", ");
4852347954 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48526,7 +47957,7 @@
4852647957 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4852747958 }
4852847959 // ACCUMULATE ARGUMENTS - END
48529- uint64_t return_to = 18446744073709549502LLU;
47960+ uint64_t return_to = 18446744073709549518LLU;
4853047961 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4853147962 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4853247963 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48535,7 +47966,7 @@
4853547966 state.addr = 839519665163075584LLU; // skip______
4853647967 break;
4853747968 }
48538- case 18446744073709549502LLU: // 99999999c8'''''''''''''''
47969+ case 18446744073709549518LLU: // 99999999dN'''''''''''''''
4853947970 {
4854047971 {
4854147972 uint64_t arg = 0;
@@ -48547,7 +47978,7 @@
4854747978 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4854847979 }
4854947980 // ACCUMULATE ARGUMENTS - END
48550- uint64_t return_to = 18446744073709549501LLU;
47981+ uint64_t return_to = 18446744073709549517LLU;
4855147982 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4855247983 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4855347984 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48556,7 +47987,7 @@
4855647987 state.addr = 861504796319285248LLU; // typeu64___
4855747988 break;
4855847989 }
48559- case 18446744073709549501LLU: // 99999999c7'''''''''''''''
47990+ case 18446744073709549517LLU: // 99999999dM'''''''''''''''
4856047991 {
4856147992 {
4856247993 uint64_t arg = 0;
@@ -48650,7 +48081,7 @@
4865048081 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4865148082 }
4865248083 // ACCUMULATE ARGUMENTS - END
48653- uint64_t return_to = 18446744073709549500LLU;
48084+ uint64_t return_to = 18446744073709549516LLU;
4865448085 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4865548086 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4865648087 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48659,7 +48090,7 @@
4865948090 state.addr = 293363126232490310LLU; // PROCVARREF
4866048091 break;
4866148092 }
48662- case 18446744073709549500LLU: // 99999999c6'''''''''''''''
48093+ case 18446744073709549516LLU: // 99999999dL'''''''''''''''
4866348094 {
4866448095 // ACCUMULATE ARGUMENTS - BEGIN
4866548096 {
@@ -48671,7 +48102,7 @@
4867148102 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4867248103 }
4867348104 // ACCUMULATE ARGUMENTS - END
48674- uint64_t return_to = 18446744073709549499LLU;
48105+ uint64_t return_to = 18446744073709549515LLU;
4867548106 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4867648107 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4867748108 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48680,7 +48111,7 @@
4868048111 state.addr = 517555565474237359LLU; // assertlist
4868148112 break;
4868248113 }
48683- case 18446744073709549499LLU: // 99999999c5'''''''''''''''
48114+ case 18446744073709549515LLU: // 99999999dK'''''''''''''''
4868448115 {
4868548116 // variable u64 mutable0__ goes out of scope
4868648117 // emitted destructur for type u64
@@ -48708,7 +48139,7 @@
4870848139 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4870948140 }
4871048141 // ACCUMULATE ARGUMENTS - END
48711- uint64_t return_to = 18446744073709549498LLU;
48142+ uint64_t return_to = 18446744073709549514LLU;
4871248143 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4871348144 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4871448145 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48717,7 +48148,7 @@
4871748148 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4871848149 break;
4871948150 }
48720- case 18446744073709549498LLU: // 99999999c4'''''''''''''''
48151+ case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
4872148152 {
4872248153 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 18
4872348154 fprintf(stdout, "%s", ");");
@@ -48727,7 +48158,7 @@
4872748158 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4872848159 }
4872948160 // ACCUMULATE ARGUMENTS - END
48730- uint64_t return_to = 18446744073709549497LLU;
48161+ uint64_t return_to = 18446744073709549513LLU;
4873148162 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4873248163 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4873348164 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48736,7 +48167,7 @@
4873648167 state.addr = 839519665163075584LLU; // skip______
4873748168 break;
4873848169 }
48739- case 18446744073709549497LLU: // 99999999c3'''''''''''''''
48170+ case 18446744073709549513LLU: // 99999999dI'''''''''''''''
4874048171 {
4874148172 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
4874248173 // variable resdest___ single____ goes out of scope
@@ -48747,7 +48178,7 @@
4874748178 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4874848179 }
4874948180 // ACCUMULATE ARGUMENTS - END
48750- uint64_t return_to = 18446744073709549496LLU;
48181+ uint64_t return_to = 18446744073709549512LLU;
4875148182 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4875248183 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4875348184 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48756,34 +48187,29 @@
4875648187 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4875748188 break;
4875848189 }
48759- case 18446744073709549496LLU: // 99999999c2'''''''''''''''
48190+ case 18446744073709549512LLU: // 99999999dH'''''''''''''''
4876048191 {
4876148192 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 17
48762- state.addr = 18446744073709549508LLU; // 99999999dD'''''''''''''''
48193+ state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
4876348194 break;
4876448195 }
48765- case 18446744073709549509LLU: // 99999999dE'''''''''''''''
48196+ case 18446744073709549525LLU: // 99999999dU'''''''''''''''
4876648197 {
48767- state.addr = 18446744073709549508LLU; // 99999999dD'''''''''''''''
48198+ state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
4876848199 break;
4876948200 }
48770- case 18446744073709549508LLU: // 99999999dD'''''''''''''''
48201+ case 18446744073709549524LLU: // 99999999dT'''''''''''''''
4877148202 {
48772- state.addr = 18446744073709549523LLU; // 99999999dS'''''''''''''''
48203+ state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
4877348204 break;
4877448205 }
48775- case 18446744073709549523LLU: // 99999999dS'''''''''''''''
48206+ case 18446744073709549539LLU: // 99999999dh'''''''''''''''
4877648207 {
48777- state.addr = 18446744073709549541LLU; // 99999999dj'''''''''''''''
48208+ state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
4877848209 break;
4877948210 }
48780- case 18446744073709549541LLU: // 99999999dj'''''''''''''''
48211+ case 18446744073709549557LLU: // 99999999dz'''''''''''''''
4878148212 {
48782- state.addr = 18446744073709549559LLU; // 99999999d1'''''''''''''''
48783- break;
48784- }
48785- case 18446744073709549559LLU: // 99999999d1'''''''''''''''
48786- {
4878748213 state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
4878848214 break;
4878948215 }
@@ -48794,6 +48220,11 @@
4879448220 }
4879548221 case 18446744073709549591LLU: // 99999999eW'''''''''''''''
4879648222 {
48223+ state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
48224+ break;
48225+ }
48226+ case 18446744073709549607LLU: // 99999999el'''''''''''''''
48227+ {
4879748228 // variable u64 sym_______ goes out of scope
4879848229 // emitted destructur for type u64
4879948230 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 16
@@ -48851,11 +48282,11 @@
4885148282 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4885248283 }
4885348284 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48854- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549495LLU : 18446744073709549494LLU;
48285+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549511LLU : 18446744073709549510LLU;
4885548286 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4885648287 break;
4885748288 }
48858- case 18446744073709549495LLU: // 99999999c1'''''''''''''''
48289+ case 18446744073709549511LLU: // 99999999dG'''''''''''''''
4885948290 {
4886048291 {
4886148292 uint64_t arg = 0;
@@ -48882,7 +48313,7 @@
4888248313 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4888348314 }
4888448315 // ACCUMULATE ARGUMENTS - END
48885- uint64_t return_to = 18446744073709549492LLU;
48316+ uint64_t return_to = 18446744073709549508LLU;
4888648317 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4888748318 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4888848319 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48891,7 +48322,7 @@
4889148322 state.addr = 861504796319285248LLU; // typeu64___
4889248323 break;
4889348324 }
48894- case 18446744073709549492LLU: // 99999999cy'''''''''''''''
48325+ case 18446744073709549508LLU: // 99999999dD'''''''''''''''
4889548326 {
4889648327 {
4889748328 uint64_t arg = 0;
@@ -48916,7 +48347,7 @@
4891648347 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4891748348 }
4891848349 // ACCUMULATE ARGUMENTS - END
48919- uint64_t return_to = 18446744073709549490LLU;
48350+ uint64_t return_to = 18446744073709549506LLU;
4892048351 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4892148352 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4892248353 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48925,7 +48356,7 @@
4892548356 state.addr = 861504796319285248LLU; // typeu64___
4892648357 break;
4892748358 }
48928- case 18446744073709549490LLU: // 99999999cw'''''''''''''''
48359+ case 18446744073709549506LLU: // 99999999dB'''''''''''''''
4892948360 {
4893048361 {
4893148362 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -48945,7 +48376,7 @@
4894548376 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4894648377 }
4894748378 // ACCUMULATE ARGUMENTS - END
48948- uint64_t return_to = 18446744073709549491LLU;
48379+ uint64_t return_to = 18446744073709549507LLU;
4894948380 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4895048381 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4895148382 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48954,7 +48385,7 @@
4895448385 state.addr = 819859607768530944LLU; // resdest___
4895548386 break;
4895648387 }
48957- case 18446744073709549491LLU: // 99999999cx'''''''''''''''
48388+ case 18446744073709549507LLU: // 99999999dC'''''''''''''''
4895848389 {
4895948390 // ACCUMULATE ARGUMENTS - BEGIN
4896048391 {
@@ -48974,7 +48405,7 @@
4897448405 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4897548406 }
4897648407 // ACCUMULATE ARGUMENTS - END
48977- uint64_t return_to = 18446744073709549489LLU;
48408+ uint64_t return_to = 18446744073709549505LLU;
4897848409 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4897948410 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4898048411 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48983,7 +48414,7 @@
4898348414 state.addr = 819857494882385920LLU; // res_u64___
4898448415 break;
4898548416 }
48986- case 18446744073709549489LLU: // 99999999cv'''''''''''''''
48417+ case 18446744073709549505LLU: // 99999999dA'''''''''''''''
4898748418 {
4898848419 // ACCUMULATE ARGUMENTS - BEGIN
4898948420 {
@@ -48991,7 +48422,7 @@
4899148422 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4899248423 }
4899348424 // ACCUMULATE ARGUMENTS - END
48994- uint64_t return_to = 18446744073709549488LLU;
48425+ uint64_t return_to = 18446744073709549504LLU;
4899548426 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4899648427 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4899748428 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49000,7 +48431,7 @@
4900048431 state.addr = 839519665163075584LLU; // skip______
4900148432 break;
4900248433 }
49003- case 18446744073709549488LLU: // 99999999cu'''''''''''''''
48434+ case 18446744073709549504LLU: // 99999999d_'''''''''''''''
4900448435 {
4900548436 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4900648437 fprintf(stdout, "%s", "\n ");
@@ -49026,7 +48457,7 @@
4902648457 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4902748458 }
4902848459 // ACCUMULATE ARGUMENTS - END
49029- uint64_t return_to = 18446744073709549487LLU;
48460+ uint64_t return_to = 18446744073709549503LLU;
4903048461 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4903148462 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4903248463 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49035,7 +48466,7 @@
4903548466 state.addr = 587881357514113024LLU; // emitpar___
4903648467 break;
4903748468 }
49038- case 18446744073709549487LLU: // 99999999ct'''''''''''''''
48469+ case 18446744073709549503LLU: // 99999999c9'''''''''''''''
4903948470 {
4904048471 fprintf(stdout, "%s", " = ");
4904148472 // ACCUMULATE ARGUMENTS - BEGIN
@@ -49044,7 +48475,7 @@
4904448475 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4904548476 }
4904648477 // ACCUMULATE ARGUMENTS - END
49047- uint64_t return_to = 18446744073709549486LLU;
48478+ uint64_t return_to = 18446744073709549502LLU;
4904848479 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4904948480 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4905048481 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49053,7 +48484,7 @@
4905348484 state.addr = 839519665163075584LLU; // skip______
4905448485 break;
4905548486 }
49056- case 18446744073709549486LLU: // 99999999cs'''''''''''''''
48487+ case 18446744073709549502LLU: // 99999999c8'''''''''''''''
4905748488 {
4905848489
4905948490 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49075,7 +48506,7 @@
4907548506 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4907648507 }
4907748508 // ACCUMULATE ARGUMENTS - END
49078- uint64_t return_to = 18446744073709549485LLU;
48509+ uint64_t return_to = 18446744073709549501LLU;
4907948510 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4908048511 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4908148512 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49084,7 +48515,7 @@
4908448515 state.addr = 23446349213393492LLU; // ASSERTINIT
4908548516 break;
4908648517 }
49087- case 18446744073709549485LLU: // 99999999cr'''''''''''''''
48518+ case 18446744073709549501LLU: // 99999999c7'''''''''''''''
4908848519 {
4908948520 {
4909048521 uint64_t arg = 0;
@@ -49163,7 +48594,7 @@
4916348594 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4916448595 }
4916548596 // ACCUMULATE ARGUMENTS - END
49166- uint64_t return_to = 18446744073709549484LLU;
48597+ uint64_t return_to = 18446744073709549500LLU;
4916748598 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4916848599 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4916948600 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49172,7 +48603,7 @@
4917248603 state.addr = 293363126232490310LLU; // PROCVARREF
4917348604 break;
4917448605 }
49175- case 18446744073709549484LLU: // 99999999cq'''''''''''''''
48606+ case 18446744073709549500LLU: // 99999999c6'''''''''''''''
4917648607 {
4917748608 // variable u64 initialize goes out of scope
4917848609 // emitted destructur for type u64
@@ -49193,7 +48624,7 @@
4919348624 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4919448625 }
4919548626 // ACCUMULATE ARGUMENTS - END
49196- uint64_t return_to = 18446744073709549483LLU;
48627+ uint64_t return_to = 18446744073709549499LLU;
4919748628 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4919848629 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4919948630 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49202,7 +48633,7 @@
4920248633 state.addr = 517555565476695680LLU; // assertu64_
4920348634 break;
4920448635 }
49205- case 18446744073709549483LLU: // 99999999cp'''''''''''''''
48636+ case 18446744073709549499LLU: // 99999999c5'''''''''''''''
4920648637 {
4920748638 // ACCUMULATE ARGUMENTS - BEGIN
4920848639 {
@@ -49210,7 +48641,7 @@
4921048641 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4921148642 }
4921248643 // ACCUMULATE ARGUMENTS - END
49213- uint64_t return_to = 18446744073709549482LLU;
48644+ uint64_t return_to = 18446744073709549498LLU;
4921448645 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4921548646 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4921648647 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49219,7 +48650,7 @@
4921948650 state.addr = 839519665163075584LLU; // skip______
4922048651 break;
4922148652 }
49222- case 18446744073709549482LLU: // 99999999co'''''''''''''''
48653+ case 18446744073709549498LLU: // 99999999c4'''''''''''''''
4922348654 {
4922448655 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4922548656 fprintf(stdout, "%s", " & ");
@@ -49229,7 +48660,7 @@
4922948660 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4923048661 }
4923148662 // ACCUMULATE ARGUMENTS - END
49232- uint64_t return_to = 18446744073709549481LLU;
48663+ uint64_t return_to = 18446744073709549497LLU;
4923348664 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4923448665 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4923548666 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49238,7 +48669,7 @@
4923848669 state.addr = 839519665163075584LLU; // skip______
4923948670 break;
4924048671 }
49241- case 18446744073709549481LLU: // 99999999cn'''''''''''''''
48672+ case 18446744073709549497LLU: // 99999999c3'''''''''''''''
4924248673 {
4924348674
4924448675 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49260,7 +48691,7 @@
4926048691 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4926148692 }
4926248693 // ACCUMULATE ARGUMENTS - END
49263- uint64_t return_to = 18446744073709549480LLU;
48694+ uint64_t return_to = 18446744073709549496LLU;
4926448695 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4926548696 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4926648697 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49269,7 +48700,7 @@
4926948700 state.addr = 23446349213393492LLU; // ASSERTINIT
4927048701 break;
4927148702 }
49272- case 18446744073709549480LLU: // 99999999cm'''''''''''''''
48703+ case 18446744073709549496LLU: // 99999999c2'''''''''''''''
4927348704 {
4927448705 {
4927548706 uint64_t arg = 0;
@@ -49348,7 +48779,7 @@
4934848779 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4934948780 }
4935048781 // ACCUMULATE ARGUMENTS - END
49351- uint64_t return_to = 18446744073709549479LLU;
48782+ uint64_t return_to = 18446744073709549495LLU;
4935248783 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4935348784 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4935448785 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49357,7 +48788,7 @@
4935748788 state.addr = 293363126232490310LLU; // PROCVARREF
4935848789 break;
4935948790 }
49360- case 18446744073709549479LLU: // 99999999cl'''''''''''''''
48791+ case 18446744073709549495LLU: // 99999999c1'''''''''''''''
4936148792 {
4936248793 // variable u64 initialize goes out of scope
4936348794 // emitted destructur for type u64
@@ -49378,7 +48809,7 @@
4937848809 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4937948810 }
4938048811 // ACCUMULATE ARGUMENTS - END
49381- uint64_t return_to = 18446744073709549478LLU;
48812+ uint64_t return_to = 18446744073709549494LLU;
4938248813 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4938348814 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4938448815 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49387,7 +48818,7 @@
4938748818 state.addr = 517555565476695680LLU; // assertu64_
4938848819 break;
4938948820 }
49390- case 18446744073709549478LLU: // 99999999ck'''''''''''''''
48821+ case 18446744073709549494LLU: // 99999999c0'''''''''''''''
4939148822 {
4939248823 // ACCUMULATE ARGUMENTS - BEGIN
4939348824 {
@@ -49395,7 +48826,7 @@
4939548826 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4939648827 }
4939748828 // ACCUMULATE ARGUMENTS - END
49398- uint64_t return_to = 18446744073709549477LLU;
48829+ uint64_t return_to = 18446744073709549493LLU;
4939948830 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4940048831 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4940148832 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49404,7 +48835,7 @@
4940448835 state.addr = 839519665163075584LLU; // skip______
4940548836 break;
4940648837 }
49407- case 18446744073709549477LLU: // 99999999cj'''''''''''''''
48838+ case 18446744073709549493LLU: // 99999999cz'''''''''''''''
4940848839 {
4940948840 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4941048841 fprintf(stdout, "%s", ";");
@@ -49416,7 +48847,7 @@
4941648847 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4941748848 }
4941848849 // ACCUMULATE ARGUMENTS - END
49419- uint64_t return_to = 18446744073709549476LLU;
48850+ uint64_t return_to = 18446744073709549492LLU;
4942048851 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4942148852 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4942248853 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49425,7 +48856,7 @@
4942548856 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
4942648857 break;
4942748858 }
49428- case 18446744073709549476LLU: // 99999999ci'''''''''''''''
48859+ case 18446744073709549492LLU: // 99999999cy'''''''''''''''
4942948860 {
4943048861 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
4943148862 // variable type______ type______ goes out of scope
@@ -49436,7 +48867,7 @@
4943648867 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4943748868 }
4943848869 // ACCUMULATE ARGUMENTS - END
49439- uint64_t return_to = 18446744073709549475LLU;
48870+ uint64_t return_to = 18446744073709549491LLU;
4944048871 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4944148872 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4944248873 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49445,7 +48876,7 @@
4944548876 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4944648877 break;
4944748878 }
49448- case 18446744073709549475LLU: // 99999999ch'''''''''''''''
48879+ case 18446744073709549491LLU: // 99999999cx'''''''''''''''
4944948880 {
4945048881 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
4945148882 // variable u64 mutable___ goes out of scope
@@ -49457,10 +48888,10 @@
4945748888 // variable u64 id________ goes out of scope
4945848889 // emitted destructur for type u64
4945948890 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
49460- state.addr = 18446744073709549493LLU; // 99999999cz'''''''''''''''
48891+ state.addr = 18446744073709549509LLU; // 99999999dE'''''''''''''''
4946148892 break;
4946248893 }
49463- case 18446744073709549494LLU: // 99999999c0'''''''''''''''
48894+ case 18446744073709549510LLU: // 99999999dF'''''''''''''''
4946448895 {
4946548896
4946648897 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 532757409974714368;
@@ -49471,11 +48902,11 @@
4947148902 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4947248903 }
4947348904 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
49474- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549474LLU : 18446744073709549473LLU;
48905+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549490LLU : 18446744073709549489LLU;
4947548906 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
4947648907 break;
4947748908 }
49478- case 18446744073709549474LLU: // 99999999cg'''''''''''''''
48909+ case 18446744073709549490LLU: // 99999999cw'''''''''''''''
4947948910 {
4948048911 {
4948148912 uint64_t arg = 0;
@@ -49502,7 +48933,7 @@
4950248933 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4950348934 }
4950448935 // ACCUMULATE ARGUMENTS - END
49505- uint64_t return_to = 18446744073709549471LLU;
48936+ uint64_t return_to = 18446744073709549487LLU;
4950648937 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4950748938 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4950848939 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49511,7 +48942,7 @@
4951148942 state.addr = 861504796319285248LLU; // typeu64___
4951248943 break;
4951348944 }
49514- case 18446744073709549471LLU: // 99999999cd'''''''''''''''
48945+ case 18446744073709549487LLU: // 99999999ct'''''''''''''''
4951548946 {
4951648947 {
4951748948 uint64_t arg = 0;
@@ -49536,7 +48967,7 @@
4953648967 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4953748968 }
4953848969 // ACCUMULATE ARGUMENTS - END
49539- uint64_t return_to = 18446744073709549469LLU;
48970+ uint64_t return_to = 18446744073709549485LLU;
4954048971 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4954148972 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4954248973 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49545,7 +48976,7 @@
4954548976 state.addr = 861504796319285248LLU; // typeu64___
4954648977 break;
4954748978 }
49548- case 18446744073709549469LLU: // 99999999cb'''''''''''''''
48979+ case 18446744073709549485LLU: // 99999999cr'''''''''''''''
4954948980 {
4955048981 {
4955148982 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -49565,7 +48996,7 @@
4956548996 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4956648997 }
4956748998 // ACCUMULATE ARGUMENTS - END
49568- uint64_t return_to = 18446744073709549470LLU;
48999+ uint64_t return_to = 18446744073709549486LLU;
4956949000 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4957049001 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4957149002 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49574,7 +49005,7 @@
4957449005 state.addr = 819859607768530944LLU; // resdest___
4957549006 break;
4957649007 }
49577- case 18446744073709549470LLU: // 99999999cc'''''''''''''''
49008+ case 18446744073709549486LLU: // 99999999cs'''''''''''''''
4957849009 {
4957949010 // ACCUMULATE ARGUMENTS - BEGIN
4958049011 {
@@ -49594,7 +49025,7 @@
4959449025 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4959549026 }
4959649027 // ACCUMULATE ARGUMENTS - END
49597- uint64_t return_to = 18446744073709549468LLU;
49028+ uint64_t return_to = 18446744073709549484LLU;
4959849029 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4959949030 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4960049031 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49603,7 +49034,7 @@
4960349034 state.addr = 819857494882385920LLU; // res_u64___
4960449035 break;
4960549036 }
49606- case 18446744073709549468LLU: // 99999999ca'''''''''''''''
49037+ case 18446744073709549484LLU: // 99999999cq'''''''''''''''
4960749038 {
4960849039 // ACCUMULATE ARGUMENTS - BEGIN
4960949040 {
@@ -49611,7 +49042,7 @@
4961149042 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4961249043 }
4961349044 // ACCUMULATE ARGUMENTS - END
49614- uint64_t return_to = 18446744073709549467LLU;
49045+ uint64_t return_to = 18446744073709549483LLU;
4961549046 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4961649047 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4961749048 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49620,7 +49051,7 @@
4962049051 state.addr = 839519665163075584LLU; // skip______
4962149052 break;
4962249053 }
49623- case 18446744073709549467LLU: // 99999999c$'''''''''''''''
49054+ case 18446744073709549483LLU: // 99999999cp'''''''''''''''
4962449055 {
4962549056 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4962649057 fprintf(stdout, "%s", "\n ");
@@ -49646,7 +49077,7 @@
4964649077 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4964749078 }
4964849079 // ACCUMULATE ARGUMENTS - END
49649- uint64_t return_to = 18446744073709549466LLU;
49080+ uint64_t return_to = 18446744073709549482LLU;
4965049081 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4965149082 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4965249083 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49655,7 +49086,7 @@
4965549086 state.addr = 587881357514113024LLU; // emitpar___
4965649087 break;
4965749088 }
49658- case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
49089+ case 18446744073709549482LLU: // 99999999co'''''''''''''''
4965949090 {
4966049091 fprintf(stdout, "%s", " = ");
4966149092 // ACCUMULATE ARGUMENTS - BEGIN
@@ -49664,7 +49095,7 @@
4966449095 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4966549096 }
4966649097 // ACCUMULATE ARGUMENTS - END
49667- uint64_t return_to = 18446744073709549465LLU;
49098+ uint64_t return_to = 18446744073709549481LLU;
4966849099 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4966949100 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4967049101 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49673,7 +49104,7 @@
4967349104 state.addr = 839519665163075584LLU; // skip______
4967449105 break;
4967549106 }
49676- case 18446744073709549465LLU: // 99999999cY'''''''''''''''
49107+ case 18446744073709549481LLU: // 99999999cn'''''''''''''''
4967749108 {
4967849109
4967949110 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49695,7 +49126,7 @@
4969549126 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4969649127 }
4969749128 // ACCUMULATE ARGUMENTS - END
49698- uint64_t return_to = 18446744073709549464LLU;
49129+ uint64_t return_to = 18446744073709549480LLU;
4969949130 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4970049131 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4970149132 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49704,7 +49135,7 @@
4970449135 state.addr = 23446349213393492LLU; // ASSERTINIT
4970549136 break;
4970649137 }
49707- case 18446744073709549464LLU: // 99999999cX'''''''''''''''
49138+ case 18446744073709549480LLU: // 99999999cm'''''''''''''''
4970849139 {
4970949140 {
4971049141 uint64_t arg = 0;
@@ -49783,7 +49214,7 @@
4978349214 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4978449215 }
4978549216 // ACCUMULATE ARGUMENTS - END
49786- uint64_t return_to = 18446744073709549463LLU;
49217+ uint64_t return_to = 18446744073709549479LLU;
4978749218 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4978849219 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4978949220 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49792,7 +49223,7 @@
4979249223 state.addr = 293363126232490310LLU; // PROCVARREF
4979349224 break;
4979449225 }
49795- case 18446744073709549463LLU: // 99999999cW'''''''''''''''
49226+ case 18446744073709549479LLU: // 99999999cl'''''''''''''''
4979649227 {
4979749228 // variable u64 initialize goes out of scope
4979849229 // emitted destructur for type u64
@@ -49813,7 +49244,7 @@
4981349244 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4981449245 }
4981549246 // ACCUMULATE ARGUMENTS - END
49816- uint64_t return_to = 18446744073709549462LLU;
49247+ uint64_t return_to = 18446744073709549478LLU;
4981749248 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4981849249 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4981949250 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49822,7 +49253,7 @@
4982249253 state.addr = 517555565476695680LLU; // assertu64_
4982349254 break;
4982449255 }
49825- case 18446744073709549462LLU: // 99999999cV'''''''''''''''
49256+ case 18446744073709549478LLU: // 99999999ck'''''''''''''''
4982649257 {
4982749258 // ACCUMULATE ARGUMENTS - BEGIN
4982849259 {
@@ -49830,7 +49261,7 @@
4983049261 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4983149262 }
4983249263 // ACCUMULATE ARGUMENTS - END
49833- uint64_t return_to = 18446744073709549461LLU;
49264+ uint64_t return_to = 18446744073709549477LLU;
4983449265 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4983549266 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4983649267 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49839,7 +49270,7 @@
4983949270 state.addr = 839519665163075584LLU; // skip______
4984049271 break;
4984149272 }
49842- case 18446744073709549461LLU: // 99999999cU'''''''''''''''
49273+ case 18446744073709549477LLU: // 99999999cj'''''''''''''''
4984349274 {
4984449275 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
4984549276 fprintf(stdout, "%s", " | ");
@@ -49849,7 +49280,7 @@
4984949280 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4985049281 }
4985149282 // ACCUMULATE ARGUMENTS - END
49852- uint64_t return_to = 18446744073709549460LLU;
49283+ uint64_t return_to = 18446744073709549476LLU;
4985349284 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4985449285 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4985549286 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49858,7 +49289,7 @@
4985849289 state.addr = 839519665163075584LLU; // skip______
4985949290 break;
4986049291 }
49861- case 18446744073709549460LLU: // 99999999cT'''''''''''''''
49292+ case 18446744073709549476LLU: // 99999999ci'''''''''''''''
4986249293 {
4986349294
4986449295 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -49880,7 +49311,7 @@
4988049311 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4988149312 }
4988249313 // ACCUMULATE ARGUMENTS - END
49883- uint64_t return_to = 18446744073709549459LLU;
49314+ uint64_t return_to = 18446744073709549475LLU;
4988449315 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4988549316 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4988649317 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49889,7 +49320,7 @@
4988949320 state.addr = 23446349213393492LLU; // ASSERTINIT
4989049321 break;
4989149322 }
49892- case 18446744073709549459LLU: // 99999999cS'''''''''''''''
49323+ case 18446744073709549475LLU: // 99999999ch'''''''''''''''
4989349324 {
4989449325 {
4989549326 uint64_t arg = 0;
@@ -49968,7 +49399,7 @@
4996849399 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4996949400 }
4997049401 // ACCUMULATE ARGUMENTS - END
49971- uint64_t return_to = 18446744073709549458LLU;
49402+ uint64_t return_to = 18446744073709549474LLU;
4997249403 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4997349404 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4997449405 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49977,7 +49408,7 @@
4997749408 state.addr = 293363126232490310LLU; // PROCVARREF
4997849409 break;
4997949410 }
49980- case 18446744073709549458LLU: // 99999999cR'''''''''''''''
49411+ case 18446744073709549474LLU: // 99999999cg'''''''''''''''
4998149412 {
4998249413 // variable u64 initialize goes out of scope
4998349414 // emitted destructur for type u64
@@ -49998,7 +49429,7 @@
4999849429 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4999949430 }
5000049431 // ACCUMULATE ARGUMENTS - END
50001- uint64_t return_to = 18446744073709549457LLU;
49432+ uint64_t return_to = 18446744073709549473LLU;
5000249433 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5000349434 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5000449435 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50007,7 +49438,7 @@
5000749438 state.addr = 517555565476695680LLU; // assertu64_
5000849439 break;
5000949440 }
50010- case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
49441+ case 18446744073709549473LLU: // 99999999cf'''''''''''''''
5001149442 {
5001249443 // ACCUMULATE ARGUMENTS - BEGIN
5001349444 {
@@ -50015,7 +49446,7 @@
5001549446 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5001649447 }
5001749448 // ACCUMULATE ARGUMENTS - END
50018- uint64_t return_to = 18446744073709549456LLU;
49449+ uint64_t return_to = 18446744073709549472LLU;
5001949450 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5002049451 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5002149452 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50024,7 +49455,7 @@
5002449455 state.addr = 839519665163075584LLU; // skip______
5002549456 break;
5002649457 }
50027- case 18446744073709549456LLU: // 99999999cP'''''''''''''''
49458+ case 18446744073709549472LLU: // 99999999ce'''''''''''''''
5002849459 {
5002949460 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5003049461 fprintf(stdout, "%s", ";");
@@ -50036,7 +49467,7 @@
5003649467 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5003749468 }
5003849469 // ACCUMULATE ARGUMENTS - END
50039- uint64_t return_to = 18446744073709549455LLU;
49470+ uint64_t return_to = 18446744073709549471LLU;
5004049471 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5004149472 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5004249473 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50045,7 +49476,7 @@
5004549476 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5004649477 break;
5004749478 }
50048- case 18446744073709549455LLU: // 99999999cO'''''''''''''''
49479+ case 18446744073709549471LLU: // 99999999cd'''''''''''''''
5004949480 {
5005049481 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5005149482 // variable type______ type______ goes out of scope
@@ -50056,7 +49487,7 @@
5005649487 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5005749488 }
5005849489 // ACCUMULATE ARGUMENTS - END
50059- uint64_t return_to = 18446744073709549454LLU;
49490+ uint64_t return_to = 18446744073709549470LLU;
5006049491 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5006149492 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5006249493 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50065,7 +49496,7 @@
5006549496 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5006649497 break;
5006749498 }
50068- case 18446744073709549454LLU: // 99999999cN'''''''''''''''
49499+ case 18446744073709549470LLU: // 99999999cc'''''''''''''''
5006949500 {
5007049501 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5007149502 // variable u64 mutable___ goes out of scope
@@ -50077,10 +49508,10 @@
5007749508 // variable u64 id________ goes out of scope
5007849509 // emitted destructur for type u64
5007949510 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
50080- state.addr = 18446744073709549472LLU; // 99999999ce'''''''''''''''
49511+ state.addr = 18446744073709549488LLU; // 99999999cu'''''''''''''''
5008149512 break;
5008249513 }
50083- case 18446744073709549473LLU: // 99999999cf'''''''''''''''
49514+ case 18446744073709549489LLU: // 99999999cv'''''''''''''''
5008449515 {
5008549516
5008649517 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 516079971752476672;
@@ -50091,11 +49522,11 @@
5009149522 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5009249523 }
5009349524 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50094- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549453LLU : 18446744073709549452LLU;
49525+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549469LLU : 18446744073709549468LLU;
5009549526 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5009649527 break;
5009749528 }
50098- case 18446744073709549453LLU: // 99999999cM'''''''''''''''
49529+ case 18446744073709549469LLU: // 99999999cb'''''''''''''''
5009949530 {
5010049531 {
5010149532 uint64_t arg = 0;
@@ -50122,7 +49553,7 @@
5012249553 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5012349554 }
5012449555 // ACCUMULATE ARGUMENTS - END
50125- uint64_t return_to = 18446744073709549450LLU;
49556+ uint64_t return_to = 18446744073709549466LLU;
5012649557 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5012749558 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5012849559 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50131,7 +49562,7 @@
5013149562 state.addr = 861504796319285248LLU; // typeu64___
5013249563 break;
5013349564 }
50134- case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
49565+ case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
5013549566 {
5013649567 {
5013749568 uint64_t arg = 0;
@@ -50156,7 +49587,7 @@
5015649587 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5015749588 }
5015849589 // ACCUMULATE ARGUMENTS - END
50159- uint64_t return_to = 18446744073709549448LLU;
49590+ uint64_t return_to = 18446744073709549464LLU;
5016049591 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5016149592 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5016249593 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50165,7 +49596,7 @@
5016549596 state.addr = 861504796319285248LLU; // typeu64___
5016649597 break;
5016749598 }
50168- case 18446744073709549448LLU: // 99999999cH'''''''''''''''
49599+ case 18446744073709549464LLU: // 99999999cX'''''''''''''''
5016949600 {
5017049601 {
5017149602 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -50185,7 +49616,7 @@
5018549616 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5018649617 }
5018749618 // ACCUMULATE ARGUMENTS - END
50188- uint64_t return_to = 18446744073709549449LLU;
49619+ uint64_t return_to = 18446744073709549465LLU;
5018949620 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5019049621 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5019149622 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50194,7 +49625,7 @@
5019449625 state.addr = 819859607768530944LLU; // resdest___
5019549626 break;
5019649627 }
50197- case 18446744073709549449LLU: // 99999999cI'''''''''''''''
49628+ case 18446744073709549465LLU: // 99999999cY'''''''''''''''
5019849629 {
5019949630 // ACCUMULATE ARGUMENTS - BEGIN
5020049631 {
@@ -50214,7 +49645,7 @@
5021449645 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5021549646 }
5021649647 // ACCUMULATE ARGUMENTS - END
50217- uint64_t return_to = 18446744073709549447LLU;
49648+ uint64_t return_to = 18446744073709549463LLU;
5021849649 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5021949650 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5022049651 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50223,7 +49654,7 @@
5022349654 state.addr = 819857494882385920LLU; // res_u64___
5022449655 break;
5022549656 }
50226- case 18446744073709549447LLU: // 99999999cG'''''''''''''''
49657+ case 18446744073709549463LLU: // 99999999cW'''''''''''''''
5022749658 {
5022849659 // ACCUMULATE ARGUMENTS - BEGIN
5022949660 {
@@ -50231,7 +49662,7 @@
5023149662 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5023249663 }
5023349664 // ACCUMULATE ARGUMENTS - END
50234- uint64_t return_to = 18446744073709549446LLU;
49665+ uint64_t return_to = 18446744073709549462LLU;
5023549666 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5023649667 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5023749668 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50240,7 +49671,7 @@
5024049671 state.addr = 839519665163075584LLU; // skip______
5024149672 break;
5024249673 }
50243- case 18446744073709549446LLU: // 99999999cF'''''''''''''''
49674+ case 18446744073709549462LLU: // 99999999cV'''''''''''''''
5024449675 {
5024549676 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5024649677 fprintf(stdout, "%s", "\n ");
@@ -50266,7 +49697,7 @@
5026649697 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5026749698 }
5026849699 // ACCUMULATE ARGUMENTS - END
50269- uint64_t return_to = 18446744073709549445LLU;
49700+ uint64_t return_to = 18446744073709549461LLU;
5027049701 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5027149702 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5027249703 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50275,7 +49706,7 @@
5027549706 state.addr = 587881357514113024LLU; // emitpar___
5027649707 break;
5027749708 }
50278- case 18446744073709549445LLU: // 99999999cE'''''''''''''''
49709+ case 18446744073709549461LLU: // 99999999cU'''''''''''''''
5027949710 {
5028049711 fprintf(stdout, "%s", " = ");
5028149712 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50284,7 +49715,7 @@
5028449715 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5028549716 }
5028649717 // ACCUMULATE ARGUMENTS - END
50287- uint64_t return_to = 18446744073709549444LLU;
49718+ uint64_t return_to = 18446744073709549460LLU;
5028849719 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5028949720 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5029049721 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50293,7 +49724,7 @@
5029349724 state.addr = 839519665163075584LLU; // skip______
5029449725 break;
5029549726 }
50296- case 18446744073709549444LLU: // 99999999cD'''''''''''''''
49727+ case 18446744073709549460LLU: // 99999999cT'''''''''''''''
5029749728 {
5029849729
5029949730 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50315,7 +49746,7 @@
5031549746 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5031649747 }
5031749748 // ACCUMULATE ARGUMENTS - END
50318- uint64_t return_to = 18446744073709549443LLU;
49749+ uint64_t return_to = 18446744073709549459LLU;
5031949750 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5032049751 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5032149752 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50324,7 +49755,7 @@
5032449755 state.addr = 23446349213393492LLU; // ASSERTINIT
5032549756 break;
5032649757 }
50327- case 18446744073709549443LLU: // 99999999cC'''''''''''''''
49758+ case 18446744073709549459LLU: // 99999999cS'''''''''''''''
5032849759 {
5032949760 {
5033049761 uint64_t arg = 0;
@@ -50403,7 +49834,7 @@
5040349834 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5040449835 }
5040549836 // ACCUMULATE ARGUMENTS - END
50406- uint64_t return_to = 18446744073709549442LLU;
49837+ uint64_t return_to = 18446744073709549458LLU;
5040749838 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5040849839 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5040949840 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50412,7 +49843,7 @@
5041249843 state.addr = 293363126232490310LLU; // PROCVARREF
5041349844 break;
5041449845 }
50415- case 18446744073709549442LLU: // 99999999cB'''''''''''''''
49846+ case 18446744073709549458LLU: // 99999999cR'''''''''''''''
5041649847 {
5041749848 // variable u64 initialize goes out of scope
5041849849 // emitted destructur for type u64
@@ -50433,7 +49864,7 @@
5043349864 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5043449865 }
5043549866 // ACCUMULATE ARGUMENTS - END
50436- uint64_t return_to = 18446744073709549441LLU;
49867+ uint64_t return_to = 18446744073709549457LLU;
5043749868 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5043849869 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5043949870 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50442,7 +49873,7 @@
5044249873 state.addr = 517555565476695680LLU; // assertu64_
5044349874 break;
5044449875 }
50445- case 18446744073709549441LLU: // 99999999cA'''''''''''''''
49876+ case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
5044649877 {
5044749878 // ACCUMULATE ARGUMENTS - BEGIN
5044849879 {
@@ -50450,7 +49881,7 @@
5045049881 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5045149882 }
5045249883 // ACCUMULATE ARGUMENTS - END
50453- uint64_t return_to = 18446744073709549440LLU;
49884+ uint64_t return_to = 18446744073709549456LLU;
5045449885 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5045549886 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5045649887 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50459,7 +49890,7 @@
5045949890 state.addr = 839519665163075584LLU; // skip______
5046049891 break;
5046149892 }
50462- case 18446744073709549440LLU: // 99999999c_'''''''''''''''
49893+ case 18446744073709549456LLU: // 99999999cP'''''''''''''''
5046349894 {
5046449895 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5046549896 fprintf(stdout, "%s", " && ");
@@ -50469,7 +49900,7 @@
5046949900 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5047049901 }
5047149902 // ACCUMULATE ARGUMENTS - END
50472- uint64_t return_to = 18446744073709549439LLU;
49903+ uint64_t return_to = 18446744073709549455LLU;
5047349904 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5047449905 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5047549906 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50478,7 +49909,7 @@
5047849909 state.addr = 839519665163075584LLU; // skip______
5047949910 break;
5048049911 }
50481- case 18446744073709549439LLU: // 99999999b9'''''''''''''''
49912+ case 18446744073709549455LLU: // 99999999cO'''''''''''''''
5048249913 {
5048349914
5048449915 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50500,7 +49931,7 @@
5050049931 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5050149932 }
5050249933 // ACCUMULATE ARGUMENTS - END
50503- uint64_t return_to = 18446744073709549438LLU;
49934+ uint64_t return_to = 18446744073709549454LLU;
5050449935 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5050549936 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5050649937 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50509,7 +49940,7 @@
5050949940 state.addr = 23446349213393492LLU; // ASSERTINIT
5051049941 break;
5051149942 }
50512- case 18446744073709549438LLU: // 99999999b8'''''''''''''''
49943+ case 18446744073709549454LLU: // 99999999cN'''''''''''''''
5051349944 {
5051449945 {
5051549946 uint64_t arg = 0;
@@ -50588,7 +50019,7 @@
5058850019 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5058950020 }
5059050021 // ACCUMULATE ARGUMENTS - END
50591- uint64_t return_to = 18446744073709549437LLU;
50022+ uint64_t return_to = 18446744073709549453LLU;
5059250023 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5059350024 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5059450025 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50597,7 +50028,7 @@
5059750028 state.addr = 293363126232490310LLU; // PROCVARREF
5059850029 break;
5059950030 }
50600- case 18446744073709549437LLU: // 99999999b7'''''''''''''''
50031+ case 18446744073709549453LLU: // 99999999cM'''''''''''''''
5060150032 {
5060250033 // variable u64 initialize goes out of scope
5060350034 // emitted destructur for type u64
@@ -50618,7 +50049,7 @@
5061850049 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5061950050 }
5062050051 // ACCUMULATE ARGUMENTS - END
50621- uint64_t return_to = 18446744073709549436LLU;
50052+ uint64_t return_to = 18446744073709549452LLU;
5062250053 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5062350054 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5062450055 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50627,7 +50058,7 @@
5062750058 state.addr = 517555565476695680LLU; // assertu64_
5062850059 break;
5062950060 }
50630- case 18446744073709549436LLU: // 99999999b6'''''''''''''''
50061+ case 18446744073709549452LLU: // 99999999cL'''''''''''''''
5063150062 {
5063250063 // ACCUMULATE ARGUMENTS - BEGIN
5063350064 {
@@ -50635,7 +50066,7 @@
5063550066 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5063650067 }
5063750068 // ACCUMULATE ARGUMENTS - END
50638- uint64_t return_to = 18446744073709549435LLU;
50069+ uint64_t return_to = 18446744073709549451LLU;
5063950070 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5064050071 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5064150072 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50644,7 +50075,7 @@
5064450075 state.addr = 839519665163075584LLU; // skip______
5064550076 break;
5064650077 }
50647- case 18446744073709549435LLU: // 99999999b5'''''''''''''''
50078+ case 18446744073709549451LLU: // 99999999cK'''''''''''''''
5064850079 {
5064950080 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5065050081 fprintf(stdout, "%s", ";");
@@ -50656,7 +50087,7 @@
5065650087 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5065750088 }
5065850089 // ACCUMULATE ARGUMENTS - END
50659- uint64_t return_to = 18446744073709549434LLU;
50090+ uint64_t return_to = 18446744073709549450LLU;
5066050091 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5066150092 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5066250093 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50665,7 +50096,7 @@
5066550096 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5066650097 break;
5066750098 }
50668- case 18446744073709549434LLU: // 99999999b4'''''''''''''''
50099+ case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
5066950100 {
5067050101 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5067150102 // variable type______ type______ goes out of scope
@@ -50676,7 +50107,7 @@
5067650107 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5067750108 }
5067850109 // ACCUMULATE ARGUMENTS - END
50679- uint64_t return_to = 18446744073709549433LLU;
50110+ uint64_t return_to = 18446744073709549449LLU;
5068050111 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5068150112 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5068250113 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50685,7 +50116,7 @@
5068550116 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5068650117 break;
5068750118 }
50688- case 18446744073709549433LLU: // 99999999b3'''''''''''''''
50119+ case 18446744073709549449LLU: // 99999999cI'''''''''''''''
5068950120 {
5069050121 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5069150122 // variable u64 mutable___ goes out of scope
@@ -50697,10 +50128,10 @@
5069750128 // variable u64 id________ goes out of scope
5069850129 // emitted destructur for type u64
5069950130 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
50700- state.addr = 18446744073709549451LLU; // 99999999cK'''''''''''''''
50131+ state.addr = 18446744073709549467LLU; // 99999999c$'''''''''''''''
5070150132 break;
5070250133 }
50703- case 18446744073709549452LLU: // 99999999cL'''''''''''''''
50134+ case 18446744073709549468LLU: // 99999999ca'''''''''''''''
5070450135 {
5070550136
5070650137 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 769271111350222848;
@@ -50711,11 +50142,11 @@
5071150142 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5071250143 }
5071350144 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50714- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549432LLU : 18446744073709549431LLU;
50145+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549448LLU : 18446744073709549447LLU;
5071550146 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5071650147 break;
5071750148 }
50718- case 18446744073709549432LLU: // 99999999b2'''''''''''''''
50149+ case 18446744073709549448LLU: // 99999999cH'''''''''''''''
5071950150 {
5072050151 {
5072150152 uint64_t arg = 0;
@@ -50742,7 +50173,7 @@
5074250173 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5074350174 }
5074450175 // ACCUMULATE ARGUMENTS - END
50745- uint64_t return_to = 18446744073709549429LLU;
50176+ uint64_t return_to = 18446744073709549445LLU;
5074650177 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5074750178 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5074850179 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50751,7 +50182,7 @@
5075150182 state.addr = 861504796319285248LLU; // typeu64___
5075250183 break;
5075350184 }
50754- case 18446744073709549429LLU: // 99999999bz'''''''''''''''
50185+ case 18446744073709549445LLU: // 99999999cE'''''''''''''''
5075550186 {
5075650187 {
5075750188 uint64_t arg = 0;
@@ -50776,7 +50207,7 @@
5077650207 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5077750208 }
5077850209 // ACCUMULATE ARGUMENTS - END
50779- uint64_t return_to = 18446744073709549427LLU;
50210+ uint64_t return_to = 18446744073709549443LLU;
5078050211 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5078150212 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5078250213 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50785,7 +50216,7 @@
5078550216 state.addr = 861504796319285248LLU; // typeu64___
5078650217 break;
5078750218 }
50788- case 18446744073709549427LLU: // 99999999bx'''''''''''''''
50219+ case 18446744073709549443LLU: // 99999999cC'''''''''''''''
5078950220 {
5079050221 {
5079150222 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -50805,7 +50236,7 @@
5080550236 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5080650237 }
5080750238 // ACCUMULATE ARGUMENTS - END
50808- uint64_t return_to = 18446744073709549428LLU;
50239+ uint64_t return_to = 18446744073709549444LLU;
5080950240 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5081050241 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5081150242 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50814,7 +50245,7 @@
5081450245 state.addr = 819859607768530944LLU; // resdest___
5081550246 break;
5081650247 }
50817- case 18446744073709549428LLU: // 99999999by'''''''''''''''
50248+ case 18446744073709549444LLU: // 99999999cD'''''''''''''''
5081850249 {
5081950250 // ACCUMULATE ARGUMENTS - BEGIN
5082050251 {
@@ -50834,7 +50265,7 @@
5083450265 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5083550266 }
5083650267 // ACCUMULATE ARGUMENTS - END
50837- uint64_t return_to = 18446744073709549426LLU;
50268+ uint64_t return_to = 18446744073709549442LLU;
5083850269 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5083950270 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5084050271 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50843,7 +50274,7 @@
5084350274 state.addr = 819857494882385920LLU; // res_u64___
5084450275 break;
5084550276 }
50846- case 18446744073709549426LLU: // 99999999bw'''''''''''''''
50277+ case 18446744073709549442LLU: // 99999999cB'''''''''''''''
5084750278 {
5084850279 // ACCUMULATE ARGUMENTS - BEGIN
5084950280 {
@@ -50851,7 +50282,7 @@
5085150282 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5085250283 }
5085350284 // ACCUMULATE ARGUMENTS - END
50854- uint64_t return_to = 18446744073709549425LLU;
50285+ uint64_t return_to = 18446744073709549441LLU;
5085550286 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5085650287 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5085750288 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50860,7 +50291,7 @@
5086050291 state.addr = 839519665163075584LLU; // skip______
5086150292 break;
5086250293 }
50863- case 18446744073709549425LLU: // 99999999bv'''''''''''''''
50294+ case 18446744073709549441LLU: // 99999999cA'''''''''''''''
5086450295 {
5086550296 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5086650297 fprintf(stdout, "%s", "\n ");
@@ -50886,7 +50317,7 @@
5088650317 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5088750318 }
5088850319 // ACCUMULATE ARGUMENTS - END
50889- uint64_t return_to = 18446744073709549424LLU;
50320+ uint64_t return_to = 18446744073709549440LLU;
5089050321 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5089150322 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5089250323 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50895,7 +50326,7 @@
5089550326 state.addr = 587881357514113024LLU; // emitpar___
5089650327 break;
5089750328 }
50898- case 18446744073709549424LLU: // 99999999bu'''''''''''''''
50329+ case 18446744073709549440LLU: // 99999999c_'''''''''''''''
5089950330 {
5090050331 fprintf(stdout, "%s", " = ");
5090150332 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50904,7 +50335,7 @@
5090450335 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5090550336 }
5090650337 // ACCUMULATE ARGUMENTS - END
50907- uint64_t return_to = 18446744073709549423LLU;
50338+ uint64_t return_to = 18446744073709549439LLU;
5090850339 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5090950340 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5091050341 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50913,7 +50344,7 @@
5091350344 state.addr = 839519665163075584LLU; // skip______
5091450345 break;
5091550346 }
50916- case 18446744073709549423LLU: // 99999999bt'''''''''''''''
50347+ case 18446744073709549439LLU: // 99999999b9'''''''''''''''
5091750348 {
5091850349
5091950350 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -50935,7 +50366,7 @@
5093550366 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5093650367 }
5093750368 // ACCUMULATE ARGUMENTS - END
50938- uint64_t return_to = 18446744073709549422LLU;
50369+ uint64_t return_to = 18446744073709549438LLU;
5093950370 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5094050371 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5094150372 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50944,7 +50375,7 @@
5094450375 state.addr = 23446349213393492LLU; // ASSERTINIT
5094550376 break;
5094650377 }
50947- case 18446744073709549422LLU: // 99999999bs'''''''''''''''
50378+ case 18446744073709549438LLU: // 99999999b8'''''''''''''''
5094850379 {
5094950380 {
5095050381 uint64_t arg = 0;
@@ -51023,7 +50454,7 @@
5102350454 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5102450455 }
5102550456 // ACCUMULATE ARGUMENTS - END
51026- uint64_t return_to = 18446744073709549421LLU;
50457+ uint64_t return_to = 18446744073709549437LLU;
5102750458 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5102850459 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5102950460 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51032,7 +50463,7 @@
5103250463 state.addr = 293363126232490310LLU; // PROCVARREF
5103350464 break;
5103450465 }
51035- case 18446744073709549421LLU: // 99999999br'''''''''''''''
50466+ case 18446744073709549437LLU: // 99999999b7'''''''''''''''
5103650467 {
5103750468 // variable u64 initialize goes out of scope
5103850469 // emitted destructur for type u64
@@ -51053,7 +50484,7 @@
5105350484 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5105450485 }
5105550486 // ACCUMULATE ARGUMENTS - END
51056- uint64_t return_to = 18446744073709549420LLU;
50487+ uint64_t return_to = 18446744073709549436LLU;
5105750488 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5105850489 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5105950490 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51062,7 +50493,7 @@
5106250493 state.addr = 517555565476695680LLU; // assertu64_
5106350494 break;
5106450495 }
51065- case 18446744073709549420LLU: // 99999999bq'''''''''''''''
50496+ case 18446744073709549436LLU: // 99999999b6'''''''''''''''
5106650497 {
5106750498 // ACCUMULATE ARGUMENTS - BEGIN
5106850499 {
@@ -51070,7 +50501,7 @@
5107050501 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5107150502 }
5107250503 // ACCUMULATE ARGUMENTS - END
51073- uint64_t return_to = 18446744073709549419LLU;
50504+ uint64_t return_to = 18446744073709549435LLU;
5107450505 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5107550506 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5107650507 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51079,7 +50510,7 @@
5107950510 state.addr = 839519665163075584LLU; // skip______
5108050511 break;
5108150512 }
51082- case 18446744073709549419LLU: // 99999999bp'''''''''''''''
50513+ case 18446744073709549435LLU: // 99999999b5'''''''''''''''
5108350514 {
5108450515 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5108550516 fprintf(stdout, "%s", " || ");
@@ -51089,7 +50520,7 @@
5108950520 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5109050521 }
5109150522 // ACCUMULATE ARGUMENTS - END
51092- uint64_t return_to = 18446744073709549418LLU;
50523+ uint64_t return_to = 18446744073709549434LLU;
5109350524 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5109450525 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5109550526 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51098,7 +50529,7 @@
5109850529 state.addr = 839519665163075584LLU; // skip______
5109950530 break;
5110050531 }
51101- case 18446744073709549418LLU: // 99999999bo'''''''''''''''
50532+ case 18446744073709549434LLU: // 99999999b4'''''''''''''''
5110250533 {
5110350534
5110450535 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51120,7 +50551,7 @@
5112050551 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5112150552 }
5112250553 // ACCUMULATE ARGUMENTS - END
51123- uint64_t return_to = 18446744073709549417LLU;
50554+ uint64_t return_to = 18446744073709549433LLU;
5112450555 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5112550556 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5112650557 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51129,7 +50560,7 @@
5112950560 state.addr = 23446349213393492LLU; // ASSERTINIT
5113050561 break;
5113150562 }
51132- case 18446744073709549417LLU: // 99999999bn'''''''''''''''
50563+ case 18446744073709549433LLU: // 99999999b3'''''''''''''''
5113350564 {
5113450565 {
5113550566 uint64_t arg = 0;
@@ -51208,7 +50639,7 @@
5120850639 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5120950640 }
5121050641 // ACCUMULATE ARGUMENTS - END
51211- uint64_t return_to = 18446744073709549416LLU;
50642+ uint64_t return_to = 18446744073709549432LLU;
5121250643 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5121350644 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5121450645 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51217,7 +50648,7 @@
5121750648 state.addr = 293363126232490310LLU; // PROCVARREF
5121850649 break;
5121950650 }
51220- case 18446744073709549416LLU: // 99999999bm'''''''''''''''
50651+ case 18446744073709549432LLU: // 99999999b2'''''''''''''''
5122150652 {
5122250653 // variable u64 initialize goes out of scope
5122350654 // emitted destructur for type u64
@@ -51238,7 +50669,7 @@
5123850669 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5123950670 }
5124050671 // ACCUMULATE ARGUMENTS - END
51241- uint64_t return_to = 18446744073709549415LLU;
50672+ uint64_t return_to = 18446744073709549431LLU;
5124250673 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5124350674 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5124450675 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51247,7 +50678,7 @@
5124750678 state.addr = 517555565476695680LLU; // assertu64_
5124850679 break;
5124950680 }
51250- case 18446744073709549415LLU: // 99999999bl'''''''''''''''
50681+ case 18446744073709549431LLU: // 99999999b1'''''''''''''''
5125150682 {
5125250683 // ACCUMULATE ARGUMENTS - BEGIN
5125350684 {
@@ -51255,7 +50686,7 @@
5125550686 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5125650687 }
5125750688 // ACCUMULATE ARGUMENTS - END
51258- uint64_t return_to = 18446744073709549414LLU;
50689+ uint64_t return_to = 18446744073709549430LLU;
5125950690 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5126050691 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5126150692 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51264,7 +50695,7 @@
5126450695 state.addr = 839519665163075584LLU; // skip______
5126550696 break;
5126650697 }
51267- case 18446744073709549414LLU: // 99999999bk'''''''''''''''
50698+ case 18446744073709549430LLU: // 99999999b0'''''''''''''''
5126850699 {
5126950700 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5127050701 fprintf(stdout, "%s", ";");
@@ -51276,7 +50707,7 @@
5127650707 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5127750708 }
5127850709 // ACCUMULATE ARGUMENTS - END
51279- uint64_t return_to = 18446744073709549413LLU;
50710+ uint64_t return_to = 18446744073709549429LLU;
5128050711 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5128150712 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5128250713 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51285,7 +50716,7 @@
5128550716 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5128650717 break;
5128750718 }
51288- case 18446744073709549413LLU: // 99999999bj'''''''''''''''
50719+ case 18446744073709549429LLU: // 99999999bz'''''''''''''''
5128950720 {
5129050721 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5129150722 // variable type______ type______ goes out of scope
@@ -51296,7 +50727,7 @@
5129650727 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5129750728 }
5129850729 // ACCUMULATE ARGUMENTS - END
51299- uint64_t return_to = 18446744073709549412LLU;
50730+ uint64_t return_to = 18446744073709549428LLU;
5130050731 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5130150732 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5130250733 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51305,7 +50736,7 @@
5130550736 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5130650737 break;
5130750738 }
51308- case 18446744073709549412LLU: // 99999999bi'''''''''''''''
50739+ case 18446744073709549428LLU: // 99999999by'''''''''''''''
5130950740 {
5131050741 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5131150742 // variable u64 mutable___ goes out of scope
@@ -51317,10 +50748,10 @@
5131750748 // variable u64 id________ goes out of scope
5131850749 // emitted destructur for type u64
5131950750 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
51320- state.addr = 18446744073709549430LLU; // 99999999b0'''''''''''''''
50751+ state.addr = 18446744073709549446LLU; // 99999999cF'''''''''''''''
5132150752 break;
5132250753 }
51323- case 18446744073709549431LLU: // 99999999b1'''''''''''''''
50754+ case 18446744073709549447LLU: // 99999999cG'''''''''''''''
5132450755 {
5132550756
5132650757 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604158353408;
@@ -51331,11 +50762,11 @@
5133150762 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5133250763 }
5133350764 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51334- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549411LLU : 18446744073709549410LLU;
50765+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549427LLU : 18446744073709549426LLU;
5133550766 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5133650767 break;
5133750768 }
51338- case 18446744073709549411LLU: // 99999999bh'''''''''''''''
50769+ case 18446744073709549427LLU: // 99999999bx'''''''''''''''
5133950770 {
5134050771 {
5134150772 uint64_t arg = 0;
@@ -51362,7 +50793,7 @@
5136250793 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5136350794 }
5136450795 // ACCUMULATE ARGUMENTS - END
51365- uint64_t return_to = 18446744073709549408LLU;
50796+ uint64_t return_to = 18446744073709549424LLU;
5136650797 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5136750798 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5136850799 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51371,7 +50802,7 @@
5137150802 state.addr = 861504796319285248LLU; // typeu64___
5137250803 break;
5137350804 }
51374- case 18446744073709549408LLU: // 99999999be'''''''''''''''
50805+ case 18446744073709549424LLU: // 99999999bu'''''''''''''''
5137550806 {
5137650807 {
5137750808 uint64_t arg = 0;
@@ -51396,7 +50827,7 @@
5139650827 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5139750828 }
5139850829 // ACCUMULATE ARGUMENTS - END
51399- uint64_t return_to = 18446744073709549406LLU;
50830+ uint64_t return_to = 18446744073709549422LLU;
5140050831 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5140150832 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5140250833 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51405,7 +50836,7 @@
5140550836 state.addr = 861504796319285248LLU; // typeu64___
5140650837 break;
5140750838 }
51408- case 18446744073709549406LLU: // 99999999bc'''''''''''''''
50839+ case 18446744073709549422LLU: // 99999999bs'''''''''''''''
5140950840 {
5141050841 {
5141150842 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -51425,7 +50856,7 @@
5142550856 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5142650857 }
5142750858 // ACCUMULATE ARGUMENTS - END
51428- uint64_t return_to = 18446744073709549407LLU;
50859+ uint64_t return_to = 18446744073709549423LLU;
5142950860 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5143050861 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5143150862 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51434,7 +50865,7 @@
5143450865 state.addr = 819859607768530944LLU; // resdest___
5143550866 break;
5143650867 }
51437- case 18446744073709549407LLU: // 99999999bd'''''''''''''''
50868+ case 18446744073709549423LLU: // 99999999bt'''''''''''''''
5143850869 {
5143950870 // ACCUMULATE ARGUMENTS - BEGIN
5144050871 {
@@ -51454,7 +50885,7 @@
5145450885 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5145550886 }
5145650887 // ACCUMULATE ARGUMENTS - END
51457- uint64_t return_to = 18446744073709549405LLU;
50888+ uint64_t return_to = 18446744073709549421LLU;
5145850889 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5145950890 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5146050891 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51463,7 +50894,7 @@
5146350894 state.addr = 819857494882385920LLU; // res_u64___
5146450895 break;
5146550896 }
51466- case 18446744073709549405LLU: // 99999999bb'''''''''''''''
50897+ case 18446744073709549421LLU: // 99999999br'''''''''''''''
5146750898 {
5146850899 // ACCUMULATE ARGUMENTS - BEGIN
5146950900 {
@@ -51471,7 +50902,7 @@
5147150902 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5147250903 }
5147350904 // ACCUMULATE ARGUMENTS - END
51474- uint64_t return_to = 18446744073709549404LLU;
50905+ uint64_t return_to = 18446744073709549420LLU;
5147550906 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5147650907 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5147750908 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51480,7 +50911,7 @@
5148050911 state.addr = 839519665163075584LLU; // skip______
5148150912 break;
5148250913 }
51483- case 18446744073709549404LLU: // 99999999ba'''''''''''''''
50914+ case 18446744073709549420LLU: // 99999999bq'''''''''''''''
5148450915 {
5148550916 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5148650917 fprintf(stdout, "%s", "\n ");
@@ -51506,7 +50937,7 @@
5150650937 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5150750938 }
5150850939 // ACCUMULATE ARGUMENTS - END
51509- uint64_t return_to = 18446744073709549403LLU;
50940+ uint64_t return_to = 18446744073709549419LLU;
5151050941 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5151150942 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5151250943 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51515,7 +50946,7 @@
5151550946 state.addr = 587881357514113024LLU; // emitpar___
5151650947 break;
5151750948 }
51518- case 18446744073709549403LLU: // 99999999b$'''''''''''''''
50949+ case 18446744073709549419LLU: // 99999999bp'''''''''''''''
5151950950 {
5152050951 fprintf(stdout, "%s", " = ");
5152150952 // ACCUMULATE ARGUMENTS - BEGIN
@@ -51524,7 +50955,7 @@
5152450955 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5152550956 }
5152650957 // ACCUMULATE ARGUMENTS - END
51527- uint64_t return_to = 18446744073709549402LLU;
50958+ uint64_t return_to = 18446744073709549418LLU;
5152850959 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5152950960 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5153050961 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51533,7 +50964,7 @@
5153350964 state.addr = 839519665163075584LLU; // skip______
5153450965 break;
5153550966 }
51536- case 18446744073709549402LLU: // 99999999bZ'''''''''''''''
50967+ case 18446744073709549418LLU: // 99999999bo'''''''''''''''
5153750968 {
5153850969
5153950970 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51555,7 +50986,7 @@
5155550986 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5155650987 }
5155750988 // ACCUMULATE ARGUMENTS - END
51558- uint64_t return_to = 18446744073709549401LLU;
50989+ uint64_t return_to = 18446744073709549417LLU;
5155950990 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5156050991 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5156150992 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51564,7 +50995,7 @@
5156450995 state.addr = 23446349213393492LLU; // ASSERTINIT
5156550996 break;
5156650997 }
51567- case 18446744073709549401LLU: // 99999999bY'''''''''''''''
50998+ case 18446744073709549417LLU: // 99999999bn'''''''''''''''
5156850999 {
5156951000 {
5157051001 uint64_t arg = 0;
@@ -51643,7 +51074,7 @@
5164351074 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5164451075 }
5164551076 // ACCUMULATE ARGUMENTS - END
51646- uint64_t return_to = 18446744073709549400LLU;
51077+ uint64_t return_to = 18446744073709549416LLU;
5164751078 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5164851079 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5164951080 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51652,7 +51083,7 @@
5165251083 state.addr = 293363126232490310LLU; // PROCVARREF
5165351084 break;
5165451085 }
51655- case 18446744073709549400LLU: // 99999999bX'''''''''''''''
51086+ case 18446744073709549416LLU: // 99999999bm'''''''''''''''
5165651087 {
5165751088 // variable u64 initialize goes out of scope
5165851089 // emitted destructur for type u64
@@ -51673,7 +51104,7 @@
5167351104 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5167451105 }
5167551106 // ACCUMULATE ARGUMENTS - END
51676- uint64_t return_to = 18446744073709549399LLU;
51107+ uint64_t return_to = 18446744073709549415LLU;
5167751108 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5167851109 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5167951110 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51682,7 +51113,7 @@
5168251113 state.addr = 517555565476695680LLU; // assertu64_
5168351114 break;
5168451115 }
51685- case 18446744073709549399LLU: // 99999999bW'''''''''''''''
51116+ case 18446744073709549415LLU: // 99999999bl'''''''''''''''
5168651117 {
5168751118 // ACCUMULATE ARGUMENTS - BEGIN
5168851119 {
@@ -51690,7 +51121,7 @@
5169051121 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5169151122 }
5169251123 // ACCUMULATE ARGUMENTS - END
51693- uint64_t return_to = 18446744073709549398LLU;
51124+ uint64_t return_to = 18446744073709549414LLU;
5169451125 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5169551126 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5169651127 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51699,7 +51130,7 @@
5169951130 state.addr = 839519665163075584LLU; // skip______
5170051131 break;
5170151132 }
51702- case 18446744073709549398LLU: // 99999999bV'''''''''''''''
51133+ case 18446744073709549414LLU: // 99999999bk'''''''''''''''
5170351134 {
5170451135 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5170551136 fprintf(stdout, "%s", " << ");
@@ -51709,7 +51140,7 @@
5170951140 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5171051141 }
5171151142 // ACCUMULATE ARGUMENTS - END
51712- uint64_t return_to = 18446744073709549397LLU;
51143+ uint64_t return_to = 18446744073709549413LLU;
5171351144 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5171451145 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5171551146 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51718,7 +51149,7 @@
5171851149 state.addr = 839519665163075584LLU; // skip______
5171951150 break;
5172051151 }
51721- case 18446744073709549397LLU: // 99999999bU'''''''''''''''
51152+ case 18446744073709549413LLU: // 99999999bj'''''''''''''''
5172251153 {
5172351154
5172451155 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -51740,7 +51171,7 @@
5174051171 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5174151172 }
5174251173 // ACCUMULATE ARGUMENTS - END
51743- uint64_t return_to = 18446744073709549396LLU;
51174+ uint64_t return_to = 18446744073709549412LLU;
5174451175 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5174551176 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5174651177 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51749,7 +51180,7 @@
5174951180 state.addr = 23446349213393492LLU; // ASSERTINIT
5175051181 break;
5175151182 }
51752- case 18446744073709549396LLU: // 99999999bT'''''''''''''''
51183+ case 18446744073709549412LLU: // 99999999bi'''''''''''''''
5175351184 {
5175451185 {
5175551186 uint64_t arg = 0;
@@ -51828,7 +51259,7 @@
5182851259 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5182951260 }
5183051261 // ACCUMULATE ARGUMENTS - END
51831- uint64_t return_to = 18446744073709549395LLU;
51262+ uint64_t return_to = 18446744073709549411LLU;
5183251263 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5183351264 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5183451265 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51837,7 +51268,7 @@
5183751268 state.addr = 293363126232490310LLU; // PROCVARREF
5183851269 break;
5183951270 }
51840- case 18446744073709549395LLU: // 99999999bS'''''''''''''''
51271+ case 18446744073709549411LLU: // 99999999bh'''''''''''''''
5184151272 {
5184251273 // variable u64 initialize goes out of scope
5184351274 // emitted destructur for type u64
@@ -51858,7 +51289,7 @@
5185851289 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5185951290 }
5186051291 // ACCUMULATE ARGUMENTS - END
51861- uint64_t return_to = 18446744073709549394LLU;
51292+ uint64_t return_to = 18446744073709549410LLU;
5186251293 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5186351294 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5186451295 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51867,7 +51298,7 @@
5186751298 state.addr = 517555565476695680LLU; // assertu64_
5186851299 break;
5186951300 }
51870- case 18446744073709549394LLU: // 99999999bR'''''''''''''''
51301+ case 18446744073709549410LLU: // 99999999bg'''''''''''''''
5187151302 {
5187251303 // ACCUMULATE ARGUMENTS - BEGIN
5187351304 {
@@ -51875,7 +51306,7 @@
5187551306 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5187651307 }
5187751308 // ACCUMULATE ARGUMENTS - END
51878- uint64_t return_to = 18446744073709549393LLU;
51309+ uint64_t return_to = 18446744073709549409LLU;
5187951310 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5188051311 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5188151312 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51884,7 +51315,7 @@
5188451315 state.addr = 839519665163075584LLU; // skip______
5188551316 break;
5188651317 }
51887- case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
51318+ case 18446744073709549409LLU: // 99999999bf'''''''''''''''
5188851319 {
5188951320 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5189051321 fprintf(stdout, "%s", ";");
@@ -51896,7 +51327,7 @@
5189651327 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5189751328 }
5189851329 // ACCUMULATE ARGUMENTS - END
51899- uint64_t return_to = 18446744073709549392LLU;
51330+ uint64_t return_to = 18446744073709549408LLU;
5190051331 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5190151332 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5190251333 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51905,7 +51336,7 @@
5190551336 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5190651337 break;
5190751338 }
51908- case 18446744073709549392LLU: // 99999999bP'''''''''''''''
51339+ case 18446744073709549408LLU: // 99999999be'''''''''''''''
5190951340 {
5191051341 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5191151342 // variable type______ type______ goes out of scope
@@ -51916,7 +51347,7 @@
5191651347 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5191751348 }
5191851349 // ACCUMULATE ARGUMENTS - END
51919- uint64_t return_to = 18446744073709549391LLU;
51350+ uint64_t return_to = 18446744073709549407LLU;
5192051351 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5192151352 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5192251353 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51925,7 +51356,7 @@
5192551356 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5192651357 break;
5192751358 }
51928- case 18446744073709549391LLU: // 99999999bO'''''''''''''''
51359+ case 18446744073709549407LLU: // 99999999bd'''''''''''''''
5192951360 {
5193051361 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5193151362 // variable u64 mutable___ goes out of scope
@@ -51937,10 +51368,10 @@
5193751368 // variable u64 id________ goes out of scope
5193851369 // emitted destructur for type u64
5193951370 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
51940- state.addr = 18446744073709549409LLU; // 99999999bf'''''''''''''''
51371+ state.addr = 18446744073709549425LLU; // 99999999bv'''''''''''''''
5194151372 break;
5194251373 }
51943- case 18446744073709549410LLU: // 99999999bg'''''''''''''''
51374+ case 18446744073709549426LLU: // 99999999bw'''''''''''''''
5194451375 {
5194551376
5194651377 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604259016704;
@@ -51951,11 +51382,11 @@
5195151382 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5195251383 }
5195351384 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51954- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549390LLU : 18446744073709549389LLU;
51385+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549406LLU : 18446744073709549405LLU;
5195551386 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5195651387 break;
5195751388 }
51958- case 18446744073709549390LLU: // 99999999bN'''''''''''''''
51389+ case 18446744073709549406LLU: // 99999999bc'''''''''''''''
5195951390 {
5196051391 {
5196151392 uint64_t arg = 0;
@@ -51982,7 +51413,7 @@
5198251413 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5198351414 }
5198451415 // ACCUMULATE ARGUMENTS - END
51985- uint64_t return_to = 18446744073709549387LLU;
51416+ uint64_t return_to = 18446744073709549403LLU;
5198651417 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5198751418 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5198851419 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51991,7 +51422,7 @@
5199151422 state.addr = 861504796319285248LLU; // typeu64___
5199251423 break;
5199351424 }
51994- case 18446744073709549387LLU: // 99999999bK'''''''''''''''
51425+ case 18446744073709549403LLU: // 99999999b$'''''''''''''''
5199551426 {
5199651427 {
5199751428 uint64_t arg = 0;
@@ -52016,7 +51447,7 @@
5201651447 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5201751448 }
5201851449 // ACCUMULATE ARGUMENTS - END
52019- uint64_t return_to = 18446744073709549385LLU;
51450+ uint64_t return_to = 18446744073709549401LLU;
5202051451 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5202151452 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5202251453 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52025,7 +51456,7 @@
5202551456 state.addr = 861504796319285248LLU; // typeu64___
5202651457 break;
5202751458 }
52028- case 18446744073709549385LLU: // 99999999bI'''''''''''''''
51459+ case 18446744073709549401LLU: // 99999999bY'''''''''''''''
5202951460 {
5203051461 {
5203151462 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -52045,7 +51476,7 @@
5204551476 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5204651477 }
5204751478 // ACCUMULATE ARGUMENTS - END
52048- uint64_t return_to = 18446744073709549386LLU;
51479+ uint64_t return_to = 18446744073709549402LLU;
5204951480 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5205051481 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5205151482 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52054,7 +51485,7 @@
5205451485 state.addr = 819859607768530944LLU; // resdest___
5205551486 break;
5205651487 }
52057- case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
51488+ case 18446744073709549402LLU: // 99999999bZ'''''''''''''''
5205851489 {
5205951490 // ACCUMULATE ARGUMENTS - BEGIN
5206051491 {
@@ -52074,7 +51505,7 @@
5207451505 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5207551506 }
5207651507 // ACCUMULATE ARGUMENTS - END
52077- uint64_t return_to = 18446744073709549384LLU;
51508+ uint64_t return_to = 18446744073709549400LLU;
5207851509 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5207951510 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5208051511 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52083,7 +51514,7 @@
5208351514 state.addr = 819857494882385920LLU; // res_u64___
5208451515 break;
5208551516 }
52086- case 18446744073709549384LLU: // 99999999bH'''''''''''''''
51517+ case 18446744073709549400LLU: // 99999999bX'''''''''''''''
5208751518 {
5208851519 // ACCUMULATE ARGUMENTS - BEGIN
5208951520 {
@@ -52091,7 +51522,7 @@
5209151522 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5209251523 }
5209351524 // ACCUMULATE ARGUMENTS - END
52094- uint64_t return_to = 18446744073709549383LLU;
51525+ uint64_t return_to = 18446744073709549399LLU;
5209551526 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5209651527 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5209751528 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52100,7 +51531,7 @@
5210051531 state.addr = 839519665163075584LLU; // skip______
5210151532 break;
5210251533 }
52103- case 18446744073709549383LLU: // 99999999bG'''''''''''''''
51534+ case 18446744073709549399LLU: // 99999999bW'''''''''''''''
5210451535 {
5210551536 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5210651537 fprintf(stdout, "%s", "\n ");
@@ -52126,7 +51557,7 @@
5212651557 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5212751558 }
5212851559 // ACCUMULATE ARGUMENTS - END
52129- uint64_t return_to = 18446744073709549382LLU;
51560+ uint64_t return_to = 18446744073709549398LLU;
5213051561 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5213151562 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5213251563 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52135,7 +51566,7 @@
5213551566 state.addr = 587881357514113024LLU; // emitpar___
5213651567 break;
5213751568 }
52138- case 18446744073709549382LLU: // 99999999bF'''''''''''''''
51569+ case 18446744073709549398LLU: // 99999999bV'''''''''''''''
5213951570 {
5214051571 fprintf(stdout, "%s", " = ");
5214151572 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52144,7 +51575,7 @@
5214451575 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5214551576 }
5214651577 // ACCUMULATE ARGUMENTS - END
52147- uint64_t return_to = 18446744073709549381LLU;
51578+ uint64_t return_to = 18446744073709549397LLU;
5214851579 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5214951580 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5215051581 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52153,7 +51584,7 @@
5215351584 state.addr = 839519665163075584LLU; // skip______
5215451585 break;
5215551586 }
52156- case 18446744073709549381LLU: // 99999999bE'''''''''''''''
51587+ case 18446744073709549397LLU: // 99999999bU'''''''''''''''
5215751588 {
5215851589
5215951590 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52175,7 +51606,7 @@
5217551606 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5217651607 }
5217751608 // ACCUMULATE ARGUMENTS - END
52178- uint64_t return_to = 18446744073709549380LLU;
51609+ uint64_t return_to = 18446744073709549396LLU;
5217951610 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5218051611 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5218151612 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52184,7 +51615,7 @@
5218451615 state.addr = 23446349213393492LLU; // ASSERTINIT
5218551616 break;
5218651617 }
52187- case 18446744073709549380LLU: // 99999999bD'''''''''''''''
51618+ case 18446744073709549396LLU: // 99999999bT'''''''''''''''
5218851619 {
5218951620 {
5219051621 uint64_t arg = 0;
@@ -52263,7 +51694,7 @@
5226351694 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5226451695 }
5226551696 // ACCUMULATE ARGUMENTS - END
52266- uint64_t return_to = 18446744073709549379LLU;
51697+ uint64_t return_to = 18446744073709549395LLU;
5226751698 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5226851699 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5226951700 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52272,7 +51703,7 @@
5227251703 state.addr = 293363126232490310LLU; // PROCVARREF
5227351704 break;
5227451705 }
52275- case 18446744073709549379LLU: // 99999999bC'''''''''''''''
51706+ case 18446744073709549395LLU: // 99999999bS'''''''''''''''
5227651707 {
5227751708 // variable u64 initialize goes out of scope
5227851709 // emitted destructur for type u64
@@ -52293,7 +51724,7 @@
5229351724 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5229451725 }
5229551726 // ACCUMULATE ARGUMENTS - END
52296- uint64_t return_to = 18446744073709549378LLU;
51727+ uint64_t return_to = 18446744073709549394LLU;
5229751728 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5229851729 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5229951730 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52302,7 +51733,7 @@
5230251733 state.addr = 517555565476695680LLU; // assertu64_
5230351734 break;
5230451735 }
52305- case 18446744073709549378LLU: // 99999999bB'''''''''''''''
51736+ case 18446744073709549394LLU: // 99999999bR'''''''''''''''
5230651737 {
5230751738 // ACCUMULATE ARGUMENTS - BEGIN
5230851739 {
@@ -52310,7 +51741,7 @@
5231051741 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5231151742 }
5231251743 // ACCUMULATE ARGUMENTS - END
52313- uint64_t return_to = 18446744073709549377LLU;
51744+ uint64_t return_to = 18446744073709549393LLU;
5231451745 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5231551746 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5231651747 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52319,7 +51750,7 @@
5231951750 state.addr = 839519665163075584LLU; // skip______
5232051751 break;
5232151752 }
52322- case 18446744073709549377LLU: // 99999999bA'''''''''''''''
51753+ case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
5232351754 {
5232451755 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5232551756 fprintf(stdout, "%s", " >> ");
@@ -52329,7 +51760,7 @@
5232951760 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5233051761 }
5233151762 // ACCUMULATE ARGUMENTS - END
52332- uint64_t return_to = 18446744073709549376LLU;
51763+ uint64_t return_to = 18446744073709549392LLU;
5233351764 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5233451765 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5233551766 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52338,7 +51769,7 @@
5233851769 state.addr = 839519665163075584LLU; // skip______
5233951770 break;
5234051771 }
52341- case 18446744073709549376LLU: // 99999999b_'''''''''''''''
51772+ case 18446744073709549392LLU: // 99999999bP'''''''''''''''
5234251773 {
5234351774
5234451775 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52360,7 +51791,7 @@
5236051791 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5236151792 }
5236251793 // ACCUMULATE ARGUMENTS - END
52363- uint64_t return_to = 18446744073709549375LLU;
51794+ uint64_t return_to = 18446744073709549391LLU;
5236451795 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5236551796 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5236651797 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52369,7 +51800,7 @@
5236951800 state.addr = 23446349213393492LLU; // ASSERTINIT
5237051801 break;
5237151802 }
52372- case 18446744073709549375LLU: // 99999999a9'''''''''''''''
51803+ case 18446744073709549391LLU: // 99999999bO'''''''''''''''
5237351804 {
5237451805 {
5237551806 uint64_t arg = 0;
@@ -52448,7 +51879,7 @@
5244851879 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5244951880 }
5245051881 // ACCUMULATE ARGUMENTS - END
52451- uint64_t return_to = 18446744073709549374LLU;
51882+ uint64_t return_to = 18446744073709549390LLU;
5245251883 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5245351884 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5245451885 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52457,7 +51888,7 @@
5245751888 state.addr = 293363126232490310LLU; // PROCVARREF
5245851889 break;
5245951890 }
52460- case 18446744073709549374LLU: // 99999999a8'''''''''''''''
51891+ case 18446744073709549390LLU: // 99999999bN'''''''''''''''
5246151892 {
5246251893 // variable u64 initialize goes out of scope
5246351894 // emitted destructur for type u64
@@ -52478,7 +51909,7 @@
5247851909 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5247951910 }
5248051911 // ACCUMULATE ARGUMENTS - END
52481- uint64_t return_to = 18446744073709549373LLU;
51912+ uint64_t return_to = 18446744073709549389LLU;
5248251913 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5248351914 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5248451915 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52487,7 +51918,7 @@
5248751918 state.addr = 517555565476695680LLU; // assertu64_
5248851919 break;
5248951920 }
52490- case 18446744073709549373LLU: // 99999999a7'''''''''''''''
51921+ case 18446744073709549389LLU: // 99999999bM'''''''''''''''
5249151922 {
5249251923 // ACCUMULATE ARGUMENTS - BEGIN
5249351924 {
@@ -52495,7 +51926,7 @@
5249551926 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5249651927 }
5249751928 // ACCUMULATE ARGUMENTS - END
52498- uint64_t return_to = 18446744073709549372LLU;
51929+ uint64_t return_to = 18446744073709549388LLU;
5249951930 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5250051931 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5250151932 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52504,7 +51935,7 @@
5250451935 state.addr = 839519665163075584LLU; // skip______
5250551936 break;
5250651937 }
52507- case 18446744073709549372LLU: // 99999999a6'''''''''''''''
51938+ case 18446744073709549388LLU: // 99999999bL'''''''''''''''
5250851939 {
5250951940 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5251051941 fprintf(stdout, "%s", ";");
@@ -52516,7 +51947,7 @@
5251651947 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5251751948 }
5251851949 // ACCUMULATE ARGUMENTS - END
52519- uint64_t return_to = 18446744073709549371LLU;
51950+ uint64_t return_to = 18446744073709549387LLU;
5252051951 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5252151952 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5252251953 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52525,7 +51956,7 @@
5252551956 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5252651957 break;
5252751958 }
52528- case 18446744073709549371LLU: // 99999999a5'''''''''''''''
51959+ case 18446744073709549387LLU: // 99999999bK'''''''''''''''
5252951960 {
5253051961 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5253151962 // variable type______ type______ goes out of scope
@@ -52536,7 +51967,7 @@
5253651967 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5253751968 }
5253851969 // ACCUMULATE ARGUMENTS - END
52539- uint64_t return_to = 18446744073709549370LLU;
51970+ uint64_t return_to = 18446744073709549386LLU;
5254051971 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5254151972 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5254251973 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52545,7 +51976,7 @@
5254551976 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5254651977 break;
5254751978 }
52548- case 18446744073709549370LLU: // 99999999a4'''''''''''''''
51979+ case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
5254951980 {
5255051981 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5255151982 // variable u64 mutable___ goes out of scope
@@ -52557,10 +51988,10 @@
5255751988 // variable u64 id________ goes out of scope
5255851989 // emitted destructur for type u64
5255951990 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
52560- state.addr = 18446744073709549388LLU; // 99999999bL'''''''''''''''
51991+ state.addr = 18446744073709549404LLU; // 99999999ba'''''''''''''''
5256151992 break;
5256251993 }
52563- case 18446744073709549389LLU: // 99999999bM'''''''''''''''
51994+ case 18446744073709549405LLU: // 99999999bb'''''''''''''''
5256451995 {
5256551996
5256651997 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 513265221985370112;
@@ -52571,11 +52002,11 @@
5257152002 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5257252003 }
5257352004 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
52574- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549369LLU : 18446744073709549368LLU;
52005+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549385LLU : 18446744073709549384LLU;
5257552006 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5257652007 break;
5257752008 }
52578- case 18446744073709549369LLU: // 99999999a3'''''''''''''''
52009+ case 18446744073709549385LLU: // 99999999bI'''''''''''''''
5257952010 {
5258052011 {
5258152012 uint64_t arg = 0;
@@ -52602,7 +52033,7 @@
5260252033 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5260352034 }
5260452035 // ACCUMULATE ARGUMENTS - END
52605- uint64_t return_to = 18446744073709549366LLU;
52036+ uint64_t return_to = 18446744073709549382LLU;
5260652037 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5260752038 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5260852039 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52611,7 +52042,7 @@
5261152042 state.addr = 861504796319285248LLU; // typeu64___
5261252043 break;
5261352044 }
52614- case 18446744073709549366LLU: // 99999999a0'''''''''''''''
52045+ case 18446744073709549382LLU: // 99999999bF'''''''''''''''
5261552046 {
5261652047 {
5261752048 uint64_t arg = 0;
@@ -52636,7 +52067,7 @@
5263652067 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5263752068 }
5263852069 // ACCUMULATE ARGUMENTS - END
52639- uint64_t return_to = 18446744073709549364LLU;
52070+ uint64_t return_to = 18446744073709549380LLU;
5264052071 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5264152072 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5264252073 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52645,7 +52076,7 @@
5264552076 state.addr = 861504796319285248LLU; // typeu64___
5264652077 break;
5264752078 }
52648- case 18446744073709549364LLU: // 99999999ay'''''''''''''''
52079+ case 18446744073709549380LLU: // 99999999bD'''''''''''''''
5264952080 {
5265052081 {
5265152082 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -52665,7 +52096,7 @@
5266552096 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5266652097 }
5266752098 // ACCUMULATE ARGUMENTS - END
52668- uint64_t return_to = 18446744073709549365LLU;
52099+ uint64_t return_to = 18446744073709549381LLU;
5266952100 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5267052101 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5267152102 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52674,7 +52105,7 @@
5267452105 state.addr = 819859607768530944LLU; // resdest___
5267552106 break;
5267652107 }
52677- case 18446744073709549365LLU: // 99999999az'''''''''''''''
52108+ case 18446744073709549381LLU: // 99999999bE'''''''''''''''
5267852109 {
5267952110 // ACCUMULATE ARGUMENTS - BEGIN
5268052111 {
@@ -52694,7 +52125,7 @@
5269452125 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5269552126 }
5269652127 // ACCUMULATE ARGUMENTS - END
52697- uint64_t return_to = 18446744073709549363LLU;
52128+ uint64_t return_to = 18446744073709549379LLU;
5269852129 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5269952130 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5270052131 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52703,7 +52134,7 @@
5270352134 state.addr = 819857494882385920LLU; // res_u64___
5270452135 break;
5270552136 }
52706- case 18446744073709549363LLU: // 99999999ax'''''''''''''''
52137+ case 18446744073709549379LLU: // 99999999bC'''''''''''''''
5270752138 {
5270852139 // ACCUMULATE ARGUMENTS - BEGIN
5270952140 {
@@ -52711,7 +52142,7 @@
5271152142 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5271252143 }
5271352144 // ACCUMULATE ARGUMENTS - END
52714- uint64_t return_to = 18446744073709549362LLU;
52145+ uint64_t return_to = 18446744073709549378LLU;
5271552146 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5271652147 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5271752148 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52720,7 +52151,7 @@
5272052151 state.addr = 839519665163075584LLU; // skip______
5272152152 break;
5272252153 }
52723- case 18446744073709549362LLU: // 99999999aw'''''''''''''''
52154+ case 18446744073709549378LLU: // 99999999bB'''''''''''''''
5272452155 {
5272552156 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5272652157 fprintf(stdout, "%s", "\n ");
@@ -52746,7 +52177,7 @@
5274652177 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5274752178 }
5274852179 // ACCUMULATE ARGUMENTS - END
52749- uint64_t return_to = 18446744073709549361LLU;
52180+ uint64_t return_to = 18446744073709549377LLU;
5275052181 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5275152182 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5275252183 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52755,7 +52186,7 @@
5275552186 state.addr = 587881357514113024LLU; // emitpar___
5275652187 break;
5275752188 }
52758- case 18446744073709549361LLU: // 99999999av'''''''''''''''
52189+ case 18446744073709549377LLU: // 99999999bA'''''''''''''''
5275952190 {
5276052191 fprintf(stdout, "%s", " = ");
5276152192 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52764,7 +52195,7 @@
5276452195 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5276552196 }
5276652197 // ACCUMULATE ARGUMENTS - END
52767- uint64_t return_to = 18446744073709549360LLU;
52198+ uint64_t return_to = 18446744073709549376LLU;
5276852199 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5276952200 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5277052201 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52773,7 +52204,7 @@
5277352204 state.addr = 839519665163075584LLU; // skip______
5277452205 break;
5277552206 }
52776- case 18446744073709549360LLU: // 99999999au'''''''''''''''
52207+ case 18446744073709549376LLU: // 99999999b_'''''''''''''''
5277752208 {
5277852209
5277952210 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52795,7 +52226,7 @@
5279552226 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5279652227 }
5279752228 // ACCUMULATE ARGUMENTS - END
52798- uint64_t return_to = 18446744073709549359LLU;
52229+ uint64_t return_to = 18446744073709549375LLU;
5279952230 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5280052231 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5280152232 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52804,7 +52235,7 @@
5280452235 state.addr = 23446349213393492LLU; // ASSERTINIT
5280552236 break;
5280652237 }
52807- case 18446744073709549359LLU: // 99999999at'''''''''''''''
52238+ case 18446744073709549375LLU: // 99999999a9'''''''''''''''
5280852239 {
5280952240 {
5281052241 uint64_t arg = 0;
@@ -52883,7 +52314,7 @@
5288352314 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5288452315 }
5288552316 // ACCUMULATE ARGUMENTS - END
52886- uint64_t return_to = 18446744073709549358LLU;
52317+ uint64_t return_to = 18446744073709549374LLU;
5288752318 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5288852319 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5288952320 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52892,7 +52323,7 @@
5289252323 state.addr = 293363126232490310LLU; // PROCVARREF
5289352324 break;
5289452325 }
52895- case 18446744073709549358LLU: // 99999999as'''''''''''''''
52326+ case 18446744073709549374LLU: // 99999999a8'''''''''''''''
5289652327 {
5289752328 // variable u64 initialize goes out of scope
5289852329 // emitted destructur for type u64
@@ -52913,7 +52344,7 @@
5291352344 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5291452345 }
5291552346 // ACCUMULATE ARGUMENTS - END
52916- uint64_t return_to = 18446744073709549357LLU;
52347+ uint64_t return_to = 18446744073709549373LLU;
5291752348 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5291852349 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5291952350 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52922,7 +52353,7 @@
5292252353 state.addr = 517555565476695680LLU; // assertu64_
5292352354 break;
5292452355 }
52925- case 18446744073709549357LLU: // 99999999ar'''''''''''''''
52356+ case 18446744073709549373LLU: // 99999999a7'''''''''''''''
5292652357 {
5292752358 // ACCUMULATE ARGUMENTS - BEGIN
5292852359 {
@@ -52930,7 +52361,7 @@
5293052361 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5293152362 }
5293252363 // ACCUMULATE ARGUMENTS - END
52933- uint64_t return_to = 18446744073709549356LLU;
52364+ uint64_t return_to = 18446744073709549372LLU;
5293452365 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5293552366 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5293652367 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52939,7 +52370,7 @@
5293952370 state.addr = 839519665163075584LLU; // skip______
5294052371 break;
5294152372 }
52942- case 18446744073709549356LLU: // 99999999aq'''''''''''''''
52373+ case 18446744073709549372LLU: // 99999999a6'''''''''''''''
5294352374 {
5294452375 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5294552376 fprintf(stdout, "%s", " + ");
@@ -52949,7 +52380,7 @@
5294952380 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5295052381 }
5295152382 // ACCUMULATE ARGUMENTS - END
52952- uint64_t return_to = 18446744073709549355LLU;
52383+ uint64_t return_to = 18446744073709549371LLU;
5295352384 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5295452385 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5295552386 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52958,7 +52389,7 @@
5295852389 state.addr = 839519665163075584LLU; // skip______
5295952390 break;
5296052391 }
52961- case 18446744073709549355LLU: // 99999999ap'''''''''''''''
52392+ case 18446744073709549371LLU: // 99999999a5'''''''''''''''
5296252393 {
5296352394
5296452395 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -52980,7 +52411,7 @@
5298052411 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5298152412 }
5298252413 // ACCUMULATE ARGUMENTS - END
52983- uint64_t return_to = 18446744073709549354LLU;
52414+ uint64_t return_to = 18446744073709549370LLU;
5298452415 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5298552416 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5298652417 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52989,7 +52420,7 @@
5298952420 state.addr = 23446349213393492LLU; // ASSERTINIT
5299052421 break;
5299152422 }
52992- case 18446744073709549354LLU: // 99999999ao'''''''''''''''
52423+ case 18446744073709549370LLU: // 99999999a4'''''''''''''''
5299352424 {
5299452425 {
5299552426 uint64_t arg = 0;
@@ -53068,7 +52499,7 @@
5306852499 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5306952500 }
5307052501 // ACCUMULATE ARGUMENTS - END
53071- uint64_t return_to = 18446744073709549353LLU;
52502+ uint64_t return_to = 18446744073709549369LLU;
5307252503 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5307352504 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5307452505 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53077,7 +52508,7 @@
5307752508 state.addr = 293363126232490310LLU; // PROCVARREF
5307852509 break;
5307952510 }
53080- case 18446744073709549353LLU: // 99999999an'''''''''''''''
52511+ case 18446744073709549369LLU: // 99999999a3'''''''''''''''
5308152512 {
5308252513 // variable u64 initialize goes out of scope
5308352514 // emitted destructur for type u64
@@ -53098,7 +52529,7 @@
5309852529 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5309952530 }
5310052531 // ACCUMULATE ARGUMENTS - END
53101- uint64_t return_to = 18446744073709549352LLU;
52532+ uint64_t return_to = 18446744073709549368LLU;
5310252533 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5310352534 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5310452535 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53107,7 +52538,7 @@
5310752538 state.addr = 517555565476695680LLU; // assertu64_
5310852539 break;
5310952540 }
53110- case 18446744073709549352LLU: // 99999999am'''''''''''''''
52541+ case 18446744073709549368LLU: // 99999999a2'''''''''''''''
5311152542 {
5311252543 // ACCUMULATE ARGUMENTS - BEGIN
5311352544 {
@@ -53115,7 +52546,7 @@
5311552546 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5311652547 }
5311752548 // ACCUMULATE ARGUMENTS - END
53118- uint64_t return_to = 18446744073709549351LLU;
52549+ uint64_t return_to = 18446744073709549367LLU;
5311952550 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5312052551 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5312152552 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53124,7 +52555,7 @@
5312452555 state.addr = 839519665163075584LLU; // skip______
5312552556 break;
5312652557 }
53127- case 18446744073709549351LLU: // 99999999al'''''''''''''''
52558+ case 18446744073709549367LLU: // 99999999a1'''''''''''''''
5312852559 {
5312952560 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5313052561 fprintf(stdout, "%s", ";");
@@ -53136,7 +52567,7 @@
5313652567 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5313752568 }
5313852569 // ACCUMULATE ARGUMENTS - END
53139- uint64_t return_to = 18446744073709549350LLU;
52570+ uint64_t return_to = 18446744073709549366LLU;
5314052571 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5314152572 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5314252573 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53145,7 +52576,7 @@
5314552576 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5314652577 break;
5314752578 }
53148- case 18446744073709549350LLU: // 99999999ak'''''''''''''''
52579+ case 18446744073709549366LLU: // 99999999a0'''''''''''''''
5314952580 {
5315052581 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5315152582 // variable type______ type______ goes out of scope
@@ -53156,7 +52587,7 @@
5315652587 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5315752588 }
5315852589 // ACCUMULATE ARGUMENTS - END
53159- uint64_t return_to = 18446744073709549349LLU;
52590+ uint64_t return_to = 18446744073709549365LLU;
5316052591 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5316152592 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5316252593 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53165,7 +52596,7 @@
5316552596 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5316652597 break;
5316752598 }
53168- case 18446744073709549349LLU: // 99999999aj'''''''''''''''
52599+ case 18446744073709549365LLU: // 99999999az'''''''''''''''
5316952600 {
5317052601 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5317152602 // variable u64 mutable___ goes out of scope
@@ -53177,10 +52608,10 @@
5317752608 // variable u64 id________ goes out of scope
5317852609 // emitted destructur for type u64
5317952610 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
53180- state.addr = 18446744073709549367LLU; // 99999999a1'''''''''''''''
52611+ state.addr = 18446744073709549383LLU; // 99999999bG'''''''''''''''
5318152612 break;
5318252613 }
53183- case 18446744073709549368LLU: // 99999999a2'''''''''''''''
52614+ case 18446744073709549384LLU: // 99999999bH'''''''''''''''
5318452615 {
5318552616
5318652617 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 842300673667104768;
@@ -53191,11 +52622,11 @@
5319152622 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5319252623 }
5319352624 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53194- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549348LLU : 18446744073709549347LLU;
52625+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549364LLU : 18446744073709549363LLU;
5319552626 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5319652627 break;
5319752628 }
53198- case 18446744073709549348LLU: // 99999999ai'''''''''''''''
52629+ case 18446744073709549364LLU: // 99999999ay'''''''''''''''
5319952630 {
5320052631 {
5320152632 uint64_t arg = 0;
@@ -53222,7 +52653,7 @@
5322252653 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5322352654 }
5322452655 // ACCUMULATE ARGUMENTS - END
53225- uint64_t return_to = 18446744073709549345LLU;
52656+ uint64_t return_to = 18446744073709549361LLU;
5322652657 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5322752658 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5322852659 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53231,7 +52662,7 @@
5323152662 state.addr = 861504796319285248LLU; // typeu64___
5323252663 break;
5323352664 }
53234- case 18446744073709549345LLU: // 99999999af'''''''''''''''
52665+ case 18446744073709549361LLU: // 99999999av'''''''''''''''
5323552666 {
5323652667 {
5323752668 uint64_t arg = 0;
@@ -53256,7 +52687,7 @@
5325652687 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5325752688 }
5325852689 // ACCUMULATE ARGUMENTS - END
53259- uint64_t return_to = 18446744073709549343LLU;
52690+ uint64_t return_to = 18446744073709549359LLU;
5326052691 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5326152692 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5326252693 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53265,7 +52696,7 @@
5326552696 state.addr = 861504796319285248LLU; // typeu64___
5326652697 break;
5326752698 }
53268- case 18446744073709549343LLU: // 99999999ad'''''''''''''''
52699+ case 18446744073709549359LLU: // 99999999at'''''''''''''''
5326952700 {
5327052701 {
5327152702 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -53285,7 +52716,7 @@
5328552716 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5328652717 }
5328752718 // ACCUMULATE ARGUMENTS - END
53288- uint64_t return_to = 18446744073709549344LLU;
52719+ uint64_t return_to = 18446744073709549360LLU;
5328952720 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5329052721 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5329152722 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53294,7 +52725,7 @@
5329452725 state.addr = 819859607768530944LLU; // resdest___
5329552726 break;
5329652727 }
53297- case 18446744073709549344LLU: // 99999999ae'''''''''''''''
52728+ case 18446744073709549360LLU: // 99999999au'''''''''''''''
5329852729 {
5329952730 // ACCUMULATE ARGUMENTS - BEGIN
5330052731 {
@@ -53314,7 +52745,7 @@
5331452745 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5331552746 }
5331652747 // ACCUMULATE ARGUMENTS - END
53317- uint64_t return_to = 18446744073709549342LLU;
52748+ uint64_t return_to = 18446744073709549358LLU;
5331852749 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5331952750 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5332052751 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53323,7 +52754,7 @@
5332352754 state.addr = 819857494882385920LLU; // res_u64___
5332452755 break;
5332552756 }
53326- case 18446744073709549342LLU: // 99999999ac'''''''''''''''
52757+ case 18446744073709549358LLU: // 99999999as'''''''''''''''
5332752758 {
5332852759 // ACCUMULATE ARGUMENTS - BEGIN
5332952760 {
@@ -53331,7 +52762,7 @@
5333152762 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5333252763 }
5333352764 // ACCUMULATE ARGUMENTS - END
53334- uint64_t return_to = 18446744073709549341LLU;
52765+ uint64_t return_to = 18446744073709549357LLU;
5333552766 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5333652767 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5333752768 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53340,7 +52771,7 @@
5334052771 state.addr = 839519665163075584LLU; // skip______
5334152772 break;
5334252773 }
53343- case 18446744073709549341LLU: // 99999999ab'''''''''''''''
52774+ case 18446744073709549357LLU: // 99999999ar'''''''''''''''
5334452775 {
5334552776 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5334652777 fprintf(stdout, "%s", "\n ");
@@ -53366,7 +52797,7 @@
5336652797 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5336752798 }
5336852799 // ACCUMULATE ARGUMENTS - END
53369- uint64_t return_to = 18446744073709549340LLU;
52800+ uint64_t return_to = 18446744073709549356LLU;
5337052801 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5337152802 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5337252803 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53375,7 +52806,7 @@
5337552806 state.addr = 587881357514113024LLU; // emitpar___
5337652807 break;
5337752808 }
53378- case 18446744073709549340LLU: // 99999999aa'''''''''''''''
52809+ case 18446744073709549356LLU: // 99999999aq'''''''''''''''
5337952810 {
5338052811 fprintf(stdout, "%s", " = ");
5338152812 // ACCUMULATE ARGUMENTS - BEGIN
@@ -53384,7 +52815,7 @@
5338452815 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5338552816 }
5338652817 // ACCUMULATE ARGUMENTS - END
53387- uint64_t return_to = 18446744073709549339LLU;
52818+ uint64_t return_to = 18446744073709549355LLU;
5338852819 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5338952820 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5339052821 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53393,7 +52824,7 @@
5339352824 state.addr = 839519665163075584LLU; // skip______
5339452825 break;
5339552826 }
53396- case 18446744073709549339LLU: // 99999999a$'''''''''''''''
52827+ case 18446744073709549355LLU: // 99999999ap'''''''''''''''
5339752828 {
5339852829
5339952830 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -53415,7 +52846,7 @@
5341552846 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5341652847 }
5341752848 // ACCUMULATE ARGUMENTS - END
53418- uint64_t return_to = 18446744073709549338LLU;
52849+ uint64_t return_to = 18446744073709549354LLU;
5341952850 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5342052851 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5342152852 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53424,7 +52855,7 @@
5342452855 state.addr = 23446349213393492LLU; // ASSERTINIT
5342552856 break;
5342652857 }
53427- case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
52858+ case 18446744073709549354LLU: // 99999999ao'''''''''''''''
5342852859 {
5342952860 {
5343052861 uint64_t arg = 0;
@@ -53503,7 +52934,7 @@
5350352934 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5350452935 }
5350552936 // ACCUMULATE ARGUMENTS - END
53506- uint64_t return_to = 18446744073709549337LLU;
52937+ uint64_t return_to = 18446744073709549353LLU;
5350752938 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5350852939 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5350952940 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53512,7 +52943,7 @@
5351252943 state.addr = 293363126232490310LLU; // PROCVARREF
5351352944 break;
5351452945 }
53515- case 18446744073709549337LLU: // 99999999aY'''''''''''''''
52946+ case 18446744073709549353LLU: // 99999999an'''''''''''''''
5351652947 {
5351752948 // variable u64 initialize goes out of scope
5351852949 // emitted destructur for type u64
@@ -53533,7 +52964,7 @@
5353352964 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5353452965 }
5353552966 // ACCUMULATE ARGUMENTS - END
53536- uint64_t return_to = 18446744073709549336LLU;
52967+ uint64_t return_to = 18446744073709549352LLU;
5353752968 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5353852969 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5353952970 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53542,7 +52973,7 @@
5354252973 state.addr = 517555565476695680LLU; // assertu64_
5354352974 break;
5354452975 }
53545- case 18446744073709549336LLU: // 99999999aX'''''''''''''''
52976+ case 18446744073709549352LLU: // 99999999am'''''''''''''''
5354652977 {
5354752978 // ACCUMULATE ARGUMENTS - BEGIN
5354852979 {
@@ -53550,7 +52981,7 @@
5355052981 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5355152982 }
5355252983 // ACCUMULATE ARGUMENTS - END
53553- uint64_t return_to = 18446744073709549335LLU;
52984+ uint64_t return_to = 18446744073709549351LLU;
5355452985 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5355552986 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5355652987 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53559,7 +52990,7 @@
5355952990 state.addr = 839519665163075584LLU; // skip______
5356052991 break;
5356152992 }
53562- case 18446744073709549335LLU: // 99999999aW'''''''''''''''
52993+ case 18446744073709549351LLU: // 99999999al'''''''''''''''
5356352994 {
5356452995 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5356552996 fprintf(stdout, "%s", " - ");
@@ -53569,7 +53000,7 @@
5356953000 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5357053001 }
5357153002 // ACCUMULATE ARGUMENTS - END
53572- uint64_t return_to = 18446744073709549334LLU;
53003+ uint64_t return_to = 18446744073709549350LLU;
5357353004 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5357453005 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5357553006 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53578,7 +53009,7 @@
5357853009 state.addr = 839519665163075584LLU; // skip______
5357953010 break;
5358053011 }
53581- case 18446744073709549334LLU: // 99999999aV'''''''''''''''
53012+ case 18446744073709549350LLU: // 99999999ak'''''''''''''''
5358253013 {
5358353014
5358453015 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -53600,7 +53031,7 @@
5360053031 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5360153032 }
5360253033 // ACCUMULATE ARGUMENTS - END
53603- uint64_t return_to = 18446744073709549333LLU;
53034+ uint64_t return_to = 18446744073709549349LLU;
5360453035 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5360553036 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5360653037 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53609,7 +53040,7 @@
5360953040 state.addr = 23446349213393492LLU; // ASSERTINIT
5361053041 break;
5361153042 }
53612- case 18446744073709549333LLU: // 99999999aU'''''''''''''''
53043+ case 18446744073709549349LLU: // 99999999aj'''''''''''''''
5361353044 {
5361453045 {
5361553046 uint64_t arg = 0;
@@ -53688,7 +53119,7 @@
5368853119 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5368953120 }
5369053121 // ACCUMULATE ARGUMENTS - END
53691- uint64_t return_to = 18446744073709549332LLU;
53122+ uint64_t return_to = 18446744073709549348LLU;
5369253123 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5369353124 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5369453125 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53697,7 +53128,7 @@
5369753128 state.addr = 293363126232490310LLU; // PROCVARREF
5369853129 break;
5369953130 }
53700- case 18446744073709549332LLU: // 99999999aT'''''''''''''''
53131+ case 18446744073709549348LLU: // 99999999ai'''''''''''''''
5370153132 {
5370253133 // variable u64 initialize goes out of scope
5370353134 // emitted destructur for type u64
@@ -53718,7 +53149,7 @@
5371853149 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5371953150 }
5372053151 // ACCUMULATE ARGUMENTS - END
53721- uint64_t return_to = 18446744073709549331LLU;
53152+ uint64_t return_to = 18446744073709549347LLU;
5372253153 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5372353154 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5372453155 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53727,7 +53158,7 @@
5372753158 state.addr = 517555565476695680LLU; // assertu64_
5372853159 break;
5372953160 }
53730- case 18446744073709549331LLU: // 99999999aS'''''''''''''''
53161+ case 18446744073709549347LLU: // 99999999ah'''''''''''''''
5373153162 {
5373253163 // ACCUMULATE ARGUMENTS - BEGIN
5373353164 {
@@ -53735,7 +53166,7 @@
5373553166 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5373653167 }
5373753168 // ACCUMULATE ARGUMENTS - END
53738- uint64_t return_to = 18446744073709549330LLU;
53169+ uint64_t return_to = 18446744073709549346LLU;
5373953170 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5374053171 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5374153172 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53744,7 +53175,7 @@
5374453175 state.addr = 839519665163075584LLU; // skip______
5374553176 break;
5374653177 }
53747- case 18446744073709549330LLU: // 99999999aR'''''''''''''''
53178+ case 18446744073709549346LLU: // 99999999ag'''''''''''''''
5374853179 {
5374953180 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5375053181 fprintf(stdout, "%s", ";");
@@ -53756,7 +53187,7 @@
5375653187 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5375753188 }
5375853189 // ACCUMULATE ARGUMENTS - END
53759- uint64_t return_to = 18446744073709549329LLU;
53190+ uint64_t return_to = 18446744073709549345LLU;
5376053191 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5376153192 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5376253193 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53765,7 +53196,7 @@
5376553196 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5376653197 break;
5376753198 }
53768- case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
53199+ case 18446744073709549345LLU: // 99999999af'''''''''''''''
5376953200 {
5377053201 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5377153202 // variable type______ type______ goes out of scope
@@ -53776,7 +53207,7 @@
5377653207 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5377753208 }
5377853209 // ACCUMULATE ARGUMENTS - END
53779- uint64_t return_to = 18446744073709549328LLU;
53210+ uint64_t return_to = 18446744073709549344LLU;
5378053211 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5378153212 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5378253213 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53785,7 +53216,7 @@
5378553216 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5378653217 break;
5378753218 }
53788- case 18446744073709549328LLU: // 99999999aP'''''''''''''''
53219+ case 18446744073709549344LLU: // 99999999ae'''''''''''''''
5378953220 {
5379053221 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5379153222 // variable u64 mutable___ goes out of scope
@@ -53797,10 +53228,10 @@
5379753228 // variable u64 id________ goes out of scope
5379853229 // emitted destructur for type u64
5379953230 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
53800- state.addr = 18446744073709549346LLU; // 99999999ag'''''''''''''''
53231+ state.addr = 18446744073709549362LLU; // 99999999aw'''''''''''''''
5380153232 break;
5380253233 }
53803- case 18446744073709549347LLU: // 99999999ah'''''''''''''''
53234+ case 18446744073709549363LLU: // 99999999ax'''''''''''''''
5380453235 {
5380553236
5380653237 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 734258263075323904;
@@ -53811,11 +53242,11 @@
5381153242 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5381253243 }
5381353244 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53814- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549327LLU : 18446744073709549326LLU;
53245+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549343LLU : 18446744073709549342LLU;
5381553246 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5381653247 break;
5381753248 }
53818- case 18446744073709549327LLU: // 99999999aO'''''''''''''''
53249+ case 18446744073709549343LLU: // 99999999ad'''''''''''''''
5381953250 {
5382053251 {
5382153252 uint64_t arg = 0;
@@ -53842,7 +53273,7 @@
5384253273 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5384353274 }
5384453275 // ACCUMULATE ARGUMENTS - END
53845- uint64_t return_to = 18446744073709549324LLU;
53276+ uint64_t return_to = 18446744073709549340LLU;
5384653277 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5384753278 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5384853279 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53851,7 +53282,7 @@
5385153282 state.addr = 861504796319285248LLU; // typeu64___
5385253283 break;
5385353284 }
53854- case 18446744073709549324LLU: // 99999999aL'''''''''''''''
53285+ case 18446744073709549340LLU: // 99999999aa'''''''''''''''
5385553286 {
5385653287 {
5385753288 uint64_t arg = 0;
@@ -53876,7 +53307,7 @@
5387653307 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5387753308 }
5387853309 // ACCUMULATE ARGUMENTS - END
53879- uint64_t return_to = 18446744073709549322LLU;
53310+ uint64_t return_to = 18446744073709549338LLU;
5388053311 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5388153312 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5388253313 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53885,7 +53316,7 @@
5388553316 state.addr = 861504796319285248LLU; // typeu64___
5388653317 break;
5388753318 }
53888- case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
53319+ case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
5388953320 {
5389053321 {
5389153322 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -53905,7 +53336,7 @@
5390553336 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5390653337 }
5390753338 // ACCUMULATE ARGUMENTS - END
53908- uint64_t return_to = 18446744073709549323LLU;
53339+ uint64_t return_to = 18446744073709549339LLU;
5390953340 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5391053341 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5391153342 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53914,7 +53345,7 @@
5391453345 state.addr = 819859607768530944LLU; // resdest___
5391553346 break;
5391653347 }
53917- case 18446744073709549323LLU: // 99999999aK'''''''''''''''
53348+ case 18446744073709549339LLU: // 99999999a$'''''''''''''''
5391853349 {
5391953350 // ACCUMULATE ARGUMENTS - BEGIN
5392053351 {
@@ -53934,7 +53365,7 @@
5393453365 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5393553366 }
5393653367 // ACCUMULATE ARGUMENTS - END
53937- uint64_t return_to = 18446744073709549321LLU;
53368+ uint64_t return_to = 18446744073709549337LLU;
5393853369 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5393953370 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5394053371 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53943,7 +53374,7 @@
5394353374 state.addr = 819857494882385920LLU; // res_u64___
5394453375 break;
5394553376 }
53946- case 18446744073709549321LLU: // 99999999aI'''''''''''''''
53377+ case 18446744073709549337LLU: // 99999999aY'''''''''''''''
5394753378 {
5394853379 // ACCUMULATE ARGUMENTS - BEGIN
5394953380 {
@@ -53951,7 +53382,7 @@
5395153382 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5395253383 }
5395353384 // ACCUMULATE ARGUMENTS - END
53954- uint64_t return_to = 18446744073709549320LLU;
53385+ uint64_t return_to = 18446744073709549336LLU;
5395553386 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5395653387 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5395753388 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53960,7 +53391,7 @@
5396053391 state.addr = 839519665163075584LLU; // skip______
5396153392 break;
5396253393 }
53963- case 18446744073709549320LLU: // 99999999aH'''''''''''''''
53394+ case 18446744073709549336LLU: // 99999999aX'''''''''''''''
5396453395 {
5396553396 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5396653397 fprintf(stdout, "%s", "\n ");
@@ -53986,7 +53417,7 @@
5398653417 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5398753418 }
5398853419 // ACCUMULATE ARGUMENTS - END
53989- uint64_t return_to = 18446744073709549319LLU;
53420+ uint64_t return_to = 18446744073709549335LLU;
5399053421 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5399153422 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5399253423 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -53995,7 +53426,7 @@
5399553426 state.addr = 587881357514113024LLU; // emitpar___
5399653427 break;
5399753428 }
53998- case 18446744073709549319LLU: // 99999999aG'''''''''''''''
53429+ case 18446744073709549335LLU: // 99999999aW'''''''''''''''
5399953430 {
5400053431 fprintf(stdout, "%s", " = ");
5400153432 // ACCUMULATE ARGUMENTS - BEGIN
@@ -54004,7 +53435,7 @@
5400453435 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5400553436 }
5400653437 // ACCUMULATE ARGUMENTS - END
54007- uint64_t return_to = 18446744073709549318LLU;
53438+ uint64_t return_to = 18446744073709549334LLU;
5400853439 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5400953440 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5401053441 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54013,7 +53444,7 @@
5401353444 state.addr = 839519665163075584LLU; // skip______
5401453445 break;
5401553446 }
54016- case 18446744073709549318LLU: // 99999999aF'''''''''''''''
53447+ case 18446744073709549334LLU: // 99999999aV'''''''''''''''
5401753448 {
5401853449
5401953450 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -54035,7 +53466,7 @@
5403553466 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5403653467 }
5403753468 // ACCUMULATE ARGUMENTS - END
54038- uint64_t return_to = 18446744073709549317LLU;
53469+ uint64_t return_to = 18446744073709549333LLU;
5403953470 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5404053471 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5404153472 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54044,7 +53475,7 @@
5404453475 state.addr = 23446349213393492LLU; // ASSERTINIT
5404553476 break;
5404653477 }
54047- case 18446744073709549317LLU: // 99999999aE'''''''''''''''
53478+ case 18446744073709549333LLU: // 99999999aU'''''''''''''''
5404853479 {
5404953480 {
5405053481 uint64_t arg = 0;
@@ -54123,7 +53554,7 @@
5412353554 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5412453555 }
5412553556 // ACCUMULATE ARGUMENTS - END
54126- uint64_t return_to = 18446744073709549316LLU;
53557+ uint64_t return_to = 18446744073709549332LLU;
5412753558 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5412853559 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5412953560 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54132,7 +53563,7 @@
5413253563 state.addr = 293363126232490310LLU; // PROCVARREF
5413353564 break;
5413453565 }
54135- case 18446744073709549316LLU: // 99999999aD'''''''''''''''
53566+ case 18446744073709549332LLU: // 99999999aT'''''''''''''''
5413653567 {
5413753568 // variable u64 initialize goes out of scope
5413853569 // emitted destructur for type u64
@@ -54153,7 +53584,7 @@
5415353584 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5415453585 }
5415553586 // ACCUMULATE ARGUMENTS - END
54156- uint64_t return_to = 18446744073709549315LLU;
53587+ uint64_t return_to = 18446744073709549331LLU;
5415753588 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5415853589 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5415953590 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54162,7 +53593,7 @@
5416253593 state.addr = 517555565476695680LLU; // assertu64_
5416353594 break;
5416453595 }
54165- case 18446744073709549315LLU: // 99999999aC'''''''''''''''
53596+ case 18446744073709549331LLU: // 99999999aS'''''''''''''''
5416653597 {
5416753598 // ACCUMULATE ARGUMENTS - BEGIN
5416853599 {
@@ -54170,7 +53601,7 @@
5417053601 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5417153602 }
5417253603 // ACCUMULATE ARGUMENTS - END
54173- uint64_t return_to = 18446744073709549314LLU;
53604+ uint64_t return_to = 18446744073709549330LLU;
5417453605 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5417553606 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5417653607 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54179,7 +53610,7 @@
5417953610 state.addr = 839519665163075584LLU; // skip______
5418053611 break;
5418153612 }
54182- case 18446744073709549314LLU: // 99999999aB'''''''''''''''
53613+ case 18446744073709549330LLU: // 99999999aR'''''''''''''''
5418353614 {
5418453615 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5418553616 fprintf(stdout, "%s", " * ");
@@ -54189,7 +53620,7 @@
5418953620 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5419053621 }
5419153622 // ACCUMULATE ARGUMENTS - END
54192- uint64_t return_to = 18446744073709549313LLU;
53623+ uint64_t return_to = 18446744073709549329LLU;
5419353624 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5419453625 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5419553626 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54198,7 +53629,7 @@
5419853629 state.addr = 839519665163075584LLU; // skip______
5419953630 break;
5420053631 }
54201- case 18446744073709549313LLU: // 99999999aA'''''''''''''''
53632+ case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
5420253633 {
5420353634
5420453635 *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
@@ -54220,7 +53651,7 @@
5422053651 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5422153652 }
5422253653 // ACCUMULATE ARGUMENTS - END
54223- uint64_t return_to = 18446744073709549312LLU;
53654+ uint64_t return_to = 18446744073709549328LLU;
5422453655 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5422553656 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5422653657 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54229,7 +53660,7 @@
5422953660 state.addr = 23446349213393492LLU; // ASSERTINIT
5423053661 break;
5423153662 }
54232- case 18446744073709549312LLU: // 99999999a_'''''''''''''''
53663+ case 18446744073709549328LLU: // 99999999aP'''''''''''''''
5423353664 {
5423453665 {
5423553666 uint64_t arg = 0;
@@ -54308,7 +53739,7 @@
5430853739 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5430953740 }
5431053741 // ACCUMULATE ARGUMENTS - END
54311- uint64_t return_to = 18446744073709549311LLU;
53742+ uint64_t return_to = 18446744073709549327LLU;
5431253743 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5431353744 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5431453745 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54317,7 +53748,7 @@
5431753748 state.addr = 293363126232490310LLU; // PROCVARREF
5431853749 break;
5431953750 }
54320- case 18446744073709549311LLU: // 99999999$9'''''''''''''''
53751+ case 18446744073709549327LLU: // 99999999aO'''''''''''''''
5432153752 {
5432253753 // variable u64 initialize goes out of scope
5432353754 // emitted destructur for type u64
@@ -54338,7 +53769,7 @@
5433853769 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5433953770 }
5434053771 // ACCUMULATE ARGUMENTS - END
54341- uint64_t return_to = 18446744073709549310LLU;
53772+ uint64_t return_to = 18446744073709549326LLU;
5434253773 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5434353774 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5434453775 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54347,7 +53778,7 @@
5434753778 state.addr = 517555565476695680LLU; // assertu64_
5434853779 break;
5434953780 }
54350- case 18446744073709549310LLU: // 99999999$8'''''''''''''''
53781+ case 18446744073709549326LLU: // 99999999aN'''''''''''''''
5435153782 {
5435253783 // ACCUMULATE ARGUMENTS - BEGIN
5435353784 {
@@ -54355,7 +53786,7 @@
5435553786 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5435653787 }
5435753788 // ACCUMULATE ARGUMENTS - END
54358- uint64_t return_to = 18446744073709549309LLU;
53789+ uint64_t return_to = 18446744073709549325LLU;
5435953790 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5436053791 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5436153792 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54364,7 +53795,7 @@
5436453795 state.addr = 839519665163075584LLU; // skip______
5436553796 break;
5436653797 }
54367- case 18446744073709549309LLU: // 99999999$7'''''''''''''''
53798+ case 18446744073709549325LLU: // 99999999aM'''''''''''''''
5436853799 {
5436953800 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
5437053801 fprintf(stdout, "%s", ";");
@@ -54376,7 +53807,7 @@
5437653807 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5437753808 }
5437853809 // ACCUMULATE ARGUMENTS - END
54379- uint64_t return_to = 18446744073709549308LLU;
53810+ uint64_t return_to = 18446744073709549324LLU;
5438053811 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5438153812 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5438253813 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54385,7 +53816,7 @@
5438553816 state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
5438653817 break;
5438753818 }
54388- case 18446744073709549308LLU: // 99999999$6'''''''''''''''
53819+ case 18446744073709549324LLU: // 99999999aL'''''''''''''''
5438953820 {
5439053821 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21
5439153822 // variable type______ type______ goes out of scope
@@ -54396,7 +53827,7 @@
5439653827 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5439753828 }
5439853829 // ACCUMULATE ARGUMENTS - END
54399- uint64_t return_to = 18446744073709549307LLU;
53830+ uint64_t return_to = 18446744073709549323LLU;
5440053831 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5440153832 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5440253833 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54405,7 +53836,7 @@
5440553836 state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5440653837 break;
5440753838 }
54408- case 18446744073709549307LLU: // 99999999$5'''''''''''''''
53839+ case 18446744073709549323LLU: // 99999999aK'''''''''''''''
5440953840 {
5441053841 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20
5441153842 // variable u64 mutable___ goes out of scope
@@ -54417,10 +53848,10 @@
5441753848 // variable u64 id________ goes out of scope
5441853849 // emitted destructur for type u64
5441953850 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17
54420- state.addr = 18446744073709549325LLU; // 99999999aM'''''''''''''''
53851+ state.addr = 18446744073709549341LLU; // 99999999ab'''''''''''''''
5442153852 break;
5442253853 }
54423- case 18446744073709549326LLU: // 99999999aN'''''''''''''''
53854+ case 18446744073709549342LLU: // 99999999ac'''''''''''''''
5442453855 {
5442553856
5442653857 *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 568794957234569216;
@@ -54431,11 +53862,11 @@
5443153862 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5443253863 }
5443353864 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
54434- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549306LLU : 18446744073709549305LLU;
53865+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549322LLU : 18446744073709549321LLU;
5443553866 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
5443653867 break;
5443753868 }
54438- case 18446744073709549306LLU: // 99999999$4'''''''''''''''
53869+ case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
5443953870 {
5444053871 {
5444153872 uint64_t arg = 0;
@@ -54462,7 +53893,7 @@
5446253893 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5446353894 }
5446453895 // ACCUMULATE ARGUMENTS - END
54465- uint64_t return_to = 18446744073709549303LLU;
53896+ uint64_t return_to = 18446744073709549319LLU;
5446653897 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5446753898 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5446853899 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54471,7 +53902,7 @@
5447153902 state.addr = 861504796319285248LLU; // typeu64___
5447253903 break;
5447353904 }
54474- case 18446744073709549303LLU: // 99999999$1'''''''''''''''
53905+ case 18446744073709549319LLU: // 99999999aG'''''''''''''''
5447553906 {
5447653907 {
5447753908 uint64_t arg = 0;
@@ -54496,7 +53927,7 @@
5449653927 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5449753928 }
5449853929 // ACCUMULATE ARGUMENTS - END
54499- uint64_t return_to = 18446744073709549301LLU;
53930+ uint64_t return_to = 18446744073709549317LLU;
5450053931 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5450153932 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5450253933 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54505,7 +53936,7 @@
5450553936 state.addr = 861504796319285248LLU; // typeu64___
5450653937 break;
5450753938 }
54508- case 18446744073709549301LLU: // 99999999$z'''''''''''''''
53939+ case 18446744073709549317LLU: // 99999999aE'''''''''''''''
5450953940 {
5451053941 {
5451153942 uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/;
@@ -54525,7 +53956,7 @@
5452553956 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5452653957 }
5452753958 // ACCUMULATE ARGUMENTS - END
54528- uint64_t return_to = 18446744073709549302LLU;
53959+ uint64_t return_to = 18446744073709549318LLU;
5452953960 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5453053961 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5453153962 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54534,7 +53965,7 @@
5453453965 state.addr = 819859607768530944LLU; // resdest___
5453553966 break;
5453653967 }
54537- case 18446744073709549302LLU: // 99999999$0'''''''''''''''
53968+ case 18446744073709549318LLU: // 99999999aF'''''''''''''''
5453853969 {
5453953970 // ACCUMULATE ARGUMENTS - BEGIN
5454053971 {
@@ -54554,7 +53985,7 @@
5455453985 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5455553986 }
5455653987 // ACCUMULATE ARGUMENTS - END
54557- uint64_t return_to = 18446744073709549300LLU;
53988+ uint64_t return_to = 18446744073709549316LLU;
5455853989 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5455953990 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5456053991 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54563,7 +53994,7 @@
5456353994 state.addr = 819857494882385920LLU; // res_u64___
5456453995 break;
5456553996 }
54566- case 18446744073709549300LLU: // 99999999$y'''''''''''''''
53997+ case 18446744073709549316LLU: // 99999999aD'''''''''''''''
5456753998 {
5456853999 // ACCUMULATE ARGUMENTS - BEGIN
5456954000 {
@@ -54571,7 +54002,7 @@
5457154002 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5457254003 }
5457354004 // ACCUMULATE ARGUMENTS - END
54574- uint64_t return_to = 18446744073709549299LLU;
54005+ uint64_t return_to = 18446744073709549315LLU;
5457554006 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5457654007 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5457754008 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -54580,7 +54011,7 @@
5458054011 state.addr = 839519665163075584LLU; // skip______
5458154012 break;
5458254013 }
54583- case 18446744073709549299LLU: // 99999999$x'''''''''''''''
54014+ case 18446744073709549315LLU: // 99999999aC'''''''''''''''
5458454015