• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revisão924 (tree)
Hora2020-02-12 06:55:11
Autorjakobthomsen

Mensagem de Log

return call-result directly

Mudança Sumário

Diff

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 923)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 924)
@@ -39463,7 +39463,7 @@
3946339463 }
3946439464 case 18446744073709549349LLU: // 99999999aj'''''''''''''''
3946539465 {
39466- swap(&/*new_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
39466+ swap(&*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
3946739467 // variable elemdef___ new_______ goes out of scope
3946839468 // (uninitialized -> no destructor-call)
3946939469 (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference new_______ at 5
@@ -39616,7 +39616,7 @@
3961639616 }
3961739617 case 18446744073709549339LLU: // 99999999a$'''''''''''''''
3961839618 {
39619- swap(&/*new_______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
39619+ swap(&*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
3962039620 // variable elemdef___ new_______ goes out of scope
3962139621 // (uninitialized -> no destructor-call)
3962239622 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference new_______ at 6
@@ -39721,7 +39721,7 @@
3972139721 }
3972239722 case 18446744073709549331LLU: // 99999999aS'''''''''''''''
3972339723 {
39724- swap(&/*new_______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
39724+ swap(&*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
3972539725 // variable elemdef___ new_______ goes out of scope
3972639726 // (uninitialized -> no destructor-call)
3972739727 (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference new_______ at 6
@@ -59228,26 +59228,57 @@
5922859228 }
5922959229 case 18446744073709548074LLU: // 99999999Ho'''''''''''''''
5923059230 {
59231- fprintf(stdout, "%s", "\n swap(&");
5923259231 {
59233- uint64_t arg = 0;
59232+ uint64_t arg = 0LLU;
5923459233 LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5923559234 }
59236- {
59237- uint64_t arg = 0;;
59235+ // ACCUMULATE ARGUMENTS - BEGIN
5923859236 {
59239- uint64_t constridx = 0LLU; // typeu64___
59240- arg = pair_move(&heap, &constridx, &arg);
59241- };
59242- *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = arg;
59243- }
59237+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 20LLU, 11LLU);
59238+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59239+ }
59240+ // ACCUMULATE ARGUMENTS - END
59241+ uint64_t return_to = 18446744073709548071LLU;
59242+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59243+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59244+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59245+ heap.data[0].elem1 = heap.data[0].elem0;
59246+ heap.data[0].elem0 = restore;
59247+ state.addr = 839519719621918720LLU; // skipws____
59248+ break;
59249+ }
59250+ case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
59251+ {
5924459252 state.addr = 18446744073709548072LLU; // 99999999Hm'''''''''''''''
5924559253 break;
5924659254 }
5924759255 case 18446744073709548072LLU: // 99999999Hm'''''''''''''''
5924859256 {
59257+ /*id1_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
59258+ // ACCUMULATE ARGUMENTS - BEGIN
59259+ {
59260+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 20LLU, 11LLU);
59261+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59262+ }
59263+ // ACCUMULATE ARGUMENTS - END
59264+ uint64_t return_to = 18446744073709548069LLU;
59265+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59266+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59267+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59268+ heap.data[0].elem1 = heap.data[0].elem0;
59269+ heap.data[0].elem0 = restore;
59270+ state.addr = 839519719621918720LLU; // skipws____
59271+ break;
59272+ }
59273+ case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
59274+ {
59275+ state.addr = 18446744073709548070LLU; // 99999999Hk'''''''''''''''
59276+ break;
59277+ }
59278+ case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
59279+ {
5924959280 {
59250- uint64_t arg = 0LLU;
59281+ uint64_t arg = 40LLU;
5925159282 LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5925259283 }
5925359284 {
@@ -59254,223 +59285,407 @@
5925459285 uint64_t arg = 0LLU;
5925559286 LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5925659287 }
59288+ /*called____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
59289+ state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548068LLU : 18446744073709548067LLU;
59290+ break;
59291+ }
59292+ case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
59293+ {
59294+ // ACCUMULATE ARGUMENTS - BEGIN
59295+ {
59296+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 22LLU, 0LLU);
59297+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59298+ }
59299+ {
59300+ uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 22LLU, 7LLU);
59301+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59302+ }
59303+ {
59304+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 18LLU), 0LLU);
59305+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59306+ }
59307+ {
59308+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 19LLU);
59309+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59310+ }
59311+ {
59312+ uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 22LLU, 15LLU);
59313+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59314+ }
59315+ // ACCUMULATE ARGUMENTS - END
59316+ uint64_t return_to = 18446744073709548065LLU;
59317+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
59318+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59319+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59320+ heap.data[0].elem1 = heap.data[0].elem0;
59321+ heap.data[0].elem0 = restore;
59322+ state.addr = 515555125197130432LLU; // allocheap_
59323+ break;
59324+ }
59325+ case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
59326+ {
59327+ state.addr = 18446744073709548066LLU; // 99999999Hg'''''''''''''''
59328+ break;
59329+ }
59330+ case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
59331+ {
5925759332 {
5925859333 uint64_t arg = 0LLU;
5925959334 LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5926059335 }
59261- {
59262- uint64_t arg = 0LLU;
59263- LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59264- }
59265- {
59266- uint64_t arg = 0LLU;
59267- LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59268- }
5926959336 // ACCUMULATE ARGUMENTS - BEGIN
5927059337 {
59271- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 25LLU, 11LLU);
59338+ uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
5927259339 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5927359340 }
59341+ {
59342+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 0LLU);
59343+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59344+ }
59345+ {
59346+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 1LLU);
59347+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59348+ }
59349+ {
59350+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 2LLU);
59351+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59352+ }
5927459353 // ACCUMULATE ARGUMENTS - END
59275- uint64_t return_to = 18446744073709548069LLU;
59276- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59354+ uint64_t return_to = 18446744073709548063LLU;
59355+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5927759356 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59278- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59357+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5927959358 heap.data[0].elem1 = heap.data[0].elem0;
5928059359 heap.data[0].elem0 = restore;
59281- state.addr = 839519719621918720LLU; // skipws____
59360+ state.addr = 768289076452424640LLU; // oneresult_
5928259361 break;
5928359362 }
59284- case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
59363+ case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
5928559364 {
59286- state.addr = 18446744073709548070LLU; // 99999999Hk'''''''''''''''
59365+ state.addr = 18446744073709548064LLU; // 99999999He'''''''''''''''
5928759366 break;
5928859367 }
59289- case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
59368+ case 18446744073709548064LLU: // 99999999He'''''''''''''''
5929059369 {
59291- /*id1_______*/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 11LLU)));
5929259370 // ACCUMULATE ARGUMENTS - BEGIN
5929359371 {
59294- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 25LLU, 11LLU);
59372+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 23LLU, 0LLU);
5929559373 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5929659374 }
59375+ {
59376+ uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 23LLU, 1LLU);
59377+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59378+ }
59379+ {
59380+ uint64_t arg = /*complete__*/*LOCAL_ACCESS(heap.data, 23LLU, 2LLU);
59381+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59382+ }
59383+ {
59384+ uint64_t arg = /*finite____*/*LOCAL_ACCESS(heap.data, 23LLU, 3LLU);
59385+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59386+ }
59387+ {
59388+ uint64_t arg = /*safe______*/*LOCAL_ACCESS(heap.data, 23LLU, 4LLU);
59389+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59390+ }
59391+ {
59392+ uint64_t arg = /*translate_*/*LOCAL_ACCESS(heap.data, 23LLU, 5LLU);
59393+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59394+ }
59395+ {
59396+ uint64_t arg = /*fndefs____*/*LOCAL_ACCESS(heap.data, 23LLU, 6LLU);
59397+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59398+ }
59399+ {
59400+ uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU);
59401+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59402+ }
59403+ {
59404+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 19LLU);
59405+ LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59406+ }
59407+ {
59408+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 23LLU, 8LLU);
59409+ LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59410+ }
59411+ {
59412+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 23LLU, 9LLU);
59413+ LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59414+ }
59415+ {
59416+ uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59417+ LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59418+ }
59419+ {
59420+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU);
59421+ LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59422+ }
59423+ {
59424+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 23LLU, 12LLU);
59425+ LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59426+ }
59427+ {
59428+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 23LLU, 13LLU);
59429+ LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59430+ }
59431+ {
59432+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 23LLU, 14LLU);
59433+ LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59434+ }
59435+ {
59436+ uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 23LLU, 15LLU);
59437+ LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59438+ }
5929759439 // ACCUMULATE ARGUMENTS - END
59298- uint64_t return_to = 18446744073709548067LLU;
59299- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59440+ uint64_t return_to = 18446744073709548061LLU;
59441+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
5930059442 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59301- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59443+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5930259444 heap.data[0].elem1 = heap.data[0].elem0;
5930359445 heap.data[0].elem0 = restore;
59304- state.addr = 839519719621918720LLU; // skipws____
59446+ state.addr = 782701543315110336LLU; // parsecall_
5930559447 break;
5930659448 }
59307- case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
59449+ case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
5930859450 {
59309- state.addr = 18446744073709548068LLU; // 99999999Hi'''''''''''''''
59451+ state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
5931059452 break;
5931159453 }
59312- case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
59454+ case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
5931359455 {
59456+ // variable list<resdest___> newresults goes out of scope
59457+ // emitted destructur for type list<resdest___>
59458+ state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
59459+ break;
59460+ }
59461+ case 18446744073709548059LLU: // 99999999H$'''''''''''''''
59462+ {
59463+ if(!*LOCAL_ACCESS(heap.data, 23LLU, 22LLU)/*list*/)
5931459464 {
59315- uint64_t arg = 40LLU;
59316- LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59465+ state.addr = 18446744073709548060LLU; // 99999999Ha'''''''''''''''
59466+ break;
5931759467 }
59468+ // temporary list-element
5931859469 {
59319- uint64_t arg = 0LLU;
59320- LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59470+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 23LLU, 22LLU)/*list*/, 8);
59471+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5932159472 }
59322- /*called____*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 27LLU, 25LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 27LLU, 11LLU));
59323- state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709548066LLU : 18446744073709548065LLU;
59324- break;
59325- }
59326- case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
59327- {
5932859473 // ACCUMULATE ARGUMENTS - BEGIN
5932959474 {
59330- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
59475+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
5933159476 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5933259477 }
5933359478 // ACCUMULATE ARGUMENTS - END
59334- uint64_t return_to = 18446744073709548063LLU;
59479+ uint64_t return_to = 18446744073709548058LLU;
5933559480 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5933659481 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5933759482 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5933859483 heap.data[0].elem1 = heap.data[0].elem0;
5933959484 heap.data[0].elem0 = restore;
59340- state.addr = 819847183515949359LLU; // reportinit
59485+ state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
5934159486 break;
5934259487 }
59343- case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
59488+ case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
5934459489 {
59345- state.addr = 18446744073709548064LLU; // 99999999He'''''''''''''''
59490+ // RELEASE temporary destructor-variable
59491+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 24
59492+ state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
59493+ break;
59494+ }
59495+ case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
59496+ {
59497+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 23
59498+ heap.availilable_size_for_dynamic_objects += 0LLU;
59499+ heap.availilable_size_for_dynamic_objects += 0LLU;
59500+ state.addr = 18446744073709548057LLU; // 99999999HY'''''''''''''''
5934659501 break;
5934759502 }
59348- case 18446744073709548064LLU: // 99999999He'''''''''''''''
59503+ case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
5934959504 {
59505+ fprintf(stdout, "%s", "\n swap(&");
5935059506 {
59351- fprintf(stderr, "%s\n", "return from call not implemented");
59352- exit(-1);
59507+ uint64_t arg = 0;
59508+ LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5935359509 }
59354- heap.availilable_size_for_dynamic_objects += 0LLU;
59355- heap.availilable_size_for_dynamic_objects += 0LLU;
59356- state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
59510+ {
59511+ uint64_t arg = 0;;
59512+ {
59513+ uint64_t constridx = 0LLU; // typeu64___
59514+ arg = pair_move(&heap, &constridx, &arg);
59515+ };
59516+ *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = arg;
59517+ }
59518+ state.addr = 18446744073709548056LLU; // 99999999HX'''''''''''''''
5935759519 break;
5935859520 }
59359- case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
59521+ case 18446744073709548056LLU: // 99999999HX'''''''''''''''
5936059522 {
5936159523 {
5936259524 uint64_t arg = 0LLU;
59525+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59526+ }
59527+ {
59528+ uint64_t arg = 0LLU;
59529+ LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59530+ }
59531+ {
59532+ uint64_t arg = 0LLU;
59533+ LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59534+ }
59535+ {
59536+ uint64_t arg = 0LLU;
59537+ LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59538+ }
59539+ {
59540+ uint64_t arg = 0LLU;
5936359541 LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5936459542 }
59543+ {
59544+ uint64_t arg = 0LLU;
59545+ LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59546+ }
59547+ {
59548+ uint64_t arg = 0LLU;
59549+ LOCAL_PUSH_MOVE(&heap, 29, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59550+ }
5936559551 // ACCUMULATE ARGUMENTS - BEGIN
5936659552 {
59367- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
59553+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 30LLU, 0LLU);
5936859554 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5936959555 }
5937059556 {
59371- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU);
59557+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 30LLU, 8LLU);
5937259558 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5937359559 }
5937459560 {
59375- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
59561+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 30LLU, 9LLU);
5937659562 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5937759563 }
5937859564 {
59379- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
59565+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 19LLU);
5938059566 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5938159567 }
5938259568 {
59383- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
59569+ uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 27LLU);
5938459570 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5938559571 }
5938659572 {
59387- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
59573+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 25LLU);
5938859574 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5938959575 }
5939059576 {
59391- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 28LLU, 11LLU);
59577+ uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 22LLU);
5939259578 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5939359579 }
5939459580 {
59395- uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
59581+ uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 24LLU);
5939659582 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5939759583 }
5939859584 {
59399- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU);
59585+ uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 26LLU);
5940059586 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5940159587 }
5940259588 {
59403- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU);
59589+ uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 23LLU);
5940459590 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5940559591 }
5940659592 {
59407- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 24LLU);
59593+ uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 28LLU);
5940859594 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5940959595 }
5941059596 {
59411- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
59597+ uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 29LLU);
5941259598 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5941359599 }
59600+ // ACCUMULATE ARGUMENTS - END
59601+ uint64_t return_to = 18446744073709548053LLU;
59602+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
59603+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59604+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59605+ heap.data[0].elem1 = heap.data[0].elem0;
59606+ heap.data[0].elem0 = restore;
59607+ state.addr = 604790753280317473LLU; // findvarref
59608+ break;
59609+ }
59610+ case 18446744073709548053LLU: // 99999999HU'''''''''''''''
59611+ {
59612+ state.addr = 18446744073709548054LLU; // 99999999HV'''''''''''''''
59613+ break;
59614+ }
59615+ case 18446744073709548054LLU: // 99999999HV'''''''''''''''
59616+ {
59617+ // ACCUMULATE ARGUMENTS - BEGIN
5941459618 {
59415- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU);
59416- LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59619+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 30LLU, 12LLU);
59620+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5941759621 }
5941859622 {
59419- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU);
59420- LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59623+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 30LLU, 13LLU);
59624+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5942159625 }
5942259626 {
59423- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU);
59424- LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59627+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 30LLU, 14LLU);
59628+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5942559629 }
59630+ {
59631+ uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 27LLU);
59632+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59633+ }
59634+ {
59635+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 25LLU);
59636+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59637+ }
5942659638 // ACCUMULATE ARGUMENTS - END
59427- uint64_t return_to = 18446744073709548060LLU;
59428- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
59639+ uint64_t return_to = 18446744073709548051LLU;
59640+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5942959641 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59430- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59642+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5943159643 heap.data[0].elem1 = heap.data[0].elem0;
5943259644 heap.data[0].elem0 = restore;
59433- state.addr = 787472342492567585LLU; // procvarref
59645+ state.addr = 587881357514113024LLU; // emitpar___
5943459646 break;
5943559647 }
59436- case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
59648+ case 18446744073709548051LLU: // 99999999HS'''''''''''''''
5943759649 {
59438- state.addr = 18446744073709548061LLU; // 99999999Hb'''''''''''''''
59650+ state.addr = 18446744073709548052LLU; // 99999999HT'''''''''''''''
5943959651 break;
5944059652 }
59441- case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
59653+ case 18446744073709548052LLU: // 99999999HT'''''''''''''''
5944259654 {
59443- // variable u64 idx_______ goes out of scope
59655+ // variable u64 consume___ goes out of scope
5944459656 // emitted destructur for type u64
59445- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 28
59446- state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
59657+ (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 30
59658+ // variable u64 optelem___ goes out of scope
59659+ // emitted destructur for type u64
59660+ (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 29
59661+ state.addr = 18446744073709548055LLU; // 99999999HW'''''''''''''''
5944759662 break;
5944859663 }
59449- case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
59664+ case 18446744073709548055LLU: // 99999999HW'''''''''''''''
5945059665 {
5945159666 // ACCUMULATE ARGUMENTS - BEGIN
5945259667 {
59453- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
59668+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
5945459669 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5945559670 }
5945659671 {
59457- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 20LLU);
59672+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
5945859673 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5945959674 }
5946059675 {
59461- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 22LLU);
59676+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 25LLU);
5946259677 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5946359678 }
5946459679 {
59465- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU);
59680+ uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 24LLU);
5946659681 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5946759682 }
5946859683 {
59469- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU);
59684+ uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 26LLU);
5947059685 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5947159686 }
5947259687 // ACCUMULATE ARGUMENTS - END
59473- uint64_t return_to = 18446744073709548058LLU;
59688+ uint64_t return_to = 18446744073709548049LLU;
5947459689 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5947559690 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5947659691 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59479,36 +59694,36 @@
5947959694 state.addr = 842862227159939072LLU; // swappable_
5948059695 break;
5948159696 }
59482- case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
59697+ case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
5948359698 {
59484- state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
59699+ state.addr = 18446744073709548050LLU; // 99999999HR'''''''''''''''
5948559700 break;
5948659701 }
59487- case 18446744073709548059LLU: // 99999999H$'''''''''''''''
59702+ case 18446744073709548050LLU: // 99999999HR'''''''''''''''
5948859703 {
5948959704 {
5949059705 uint64_t arg = 819865187908583424LLU;
59491- LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59706+ LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5949259707 }
5949359708 // ACCUMULATE ARGUMENTS - BEGIN
5949459709 {
59495- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
59710+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
5949659711 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5949759712 }
5949859713 {
59499- uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
59714+ uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU);
5950059715 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5950159716 }
5950259717 {
59503- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
59718+ uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU);
5950459719 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5950559720 }
5950659721 {
59507- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
59722+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU);
5950859723 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5950959724 }
5951059725 // ACCUMULATE ARGUMENTS - END
59511- uint64_t return_to = 18446744073709548056LLU;
59726+ uint64_t return_to = 18446744073709548047LLU;
5951259727 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5951359728 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5951459729 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59517,32 +59732,32 @@
5951759732 state.addr = 660220410725010287LLU; // initassert
5951859733 break;
5951959734 }
59520- case 18446744073709548056LLU: // 99999999HX'''''''''''''''
59735+ case 18446744073709548047LLU: // 99999999HO'''''''''''''''
5952159736 {
59522- state.addr = 18446744073709548057LLU; // 99999999HY'''''''''''''''
59737+ state.addr = 18446744073709548048LLU; // 99999999HP'''''''''''''''
5952359738 break;
5952459739 }
59525- case 18446744073709548057LLU: // 99999999HY'''''''''''''''
59740+ case 18446744073709548048LLU: // 99999999HP'''''''''''''''
5952659741 {
5952759742 // ACCUMULATE ARGUMENTS - BEGIN
5952859743 {
59529- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
59744+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
5953059745 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5953159746 }
5953259747 {
59533- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
59748+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU);
5953459749 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5953559750 }
5953659751 {
59537- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
59752+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU);
5953859753 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5953959754 }
5954059755 {
59541- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
59756+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU);
5954259757 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5954359758 }
5954459759 // ACCUMULATE ARGUMENTS - END
59545- uint64_t return_to = 18446744073709548054LLU;
59760+ uint64_t return_to = 18446744073709548045LLU;
5954659761 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5954759762 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5954859763 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59551,42 +59766,28 @@
5955159766 state.addr = 732615645798520865LLU; // movevarref
5955259767 break;
5955359768 }
59554- case 18446744073709548054LLU: // 99999999HV'''''''''''''''
59769+ case 18446744073709548045LLU: // 99999999HM'''''''''''''''
5955559770 {
59556- state.addr = 18446744073709548055LLU; // 99999999HW'''''''''''''''
59771+ state.addr = 18446744073709548046LLU; // 99999999HN'''''''''''''''
5955759772 break;
5955859773 }
59559- case 18446744073709548055LLU: // 99999999HW'''''''''''''''
59774+ case 18446744073709548046LLU: // 99999999HN'''''''''''''''
5956059775 {
59561- // variable u64 info______ goes out of scope
59562- // emitted destructur for type u64
59563- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 28
59564- // variable u64 called____ goes out of scope
59565- // emitted destructur for type u64
59566- (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 27
59567- // variable u64 sym_______ goes out of scope
59568- // emitted destructur for type u64
59569- (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 26
59570- state.addr = 18446744073709548071LLU; // 99999999Hl'''''''''''''''
59571- break;
59572- }
59573- case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
59574- {
5957559776 // ACCUMULATE ARGUMENTS - BEGIN
5957659777 {
59577- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 25LLU, 0LLU);
59778+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
5957859779 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5957959780 }
5958059781 {
59581- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 25LLU, 18LLU), 0LLU);
59782+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 0LLU);
5958259783 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5958359784 }
5958459785 {
59585- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 25LLU, 19LLU);
59786+ uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU);
5958659787 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5958759788 }
5958859789 // ACCUMULATE ARGUMENTS - END
59589- uint64_t return_to = 18446744073709548052LLU;
59790+ uint64_t return_to = 18446744073709548043LLU;
5959059791 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5959159792 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5959259793 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59595,77 +59796,37 @@
5959559796 state.addr = 861504774606556015LLU; // typeassert
5959659797 break;
5959759798 }
59598- case 18446744073709548052LLU: // 99999999HT'''''''''''''''
59799+ case 18446744073709548043LLU: // 99999999HK'''''''''''''''
5959959800 {
59600- state.addr = 18446744073709548053LLU; // 99999999HU'''''''''''''''
59801+ state.addr = 18446744073709548044LLU; // 99999999HL'''''''''''''''
5960159802 break;
5960259803 }
59603- case 18446744073709548053LLU: // 99999999HU'''''''''''''''
59804+ case 18446744073709548044LLU: // 99999999HL'''''''''''''''
5960459805 {
59605- // variable u64 parameter_ goes out of scope
59606- // emitted destructur for type u64
59607- (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 25
59608- // variable u64 mutable___ goes out of scope
59609- // emitted destructur for type u64
59610- (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 24
59611- // variable u64 INDIRECT__ goes out of scope
59612- // emitted destructur for type u64
59613- (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 23
59614- // variable u64 init1_____ goes out of scope
59615- // emitted destructur for type u64
59616- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 22
59617- // variable u64 id1_______ goes out of scope
59618- // emitted destructur for type u64
59619- (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 21
59620- // variable type______ typesrc___ goes out of scope
59621- // emitted destructur for type type______
59622- // ACCUMULATE ARGUMENTS - BEGIN
59623- {
59624- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
59625- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59626- }
59627- // ACCUMULATE ARGUMENTS - END
59628- uint64_t return_to = 18446744073709548051LLU;
59629- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59630- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59631- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59632- heap.data[0].elem1 = heap.data[0].elem0;
59633- heap.data[0].elem0 = restore;
59634- state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
59635- break;
59636- }
59637- case 18446744073709548051LLU: // 99999999HS'''''''''''''''
59638- {
59639- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 20
59640- state.addr = 18446744073709548073LLU; // 99999999Hn'''''''''''''''
59641- break;
59642- }
59643- case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
59644- {
5964559806 fprintf(stdout, "%s", ", &");
5964659807 // ACCUMULATE ARGUMENTS - BEGIN
5964759808 {
59648- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 19LLU, 12LLU);
59809+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU);
5964959810 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5965059811 }
5965159812 {
59652- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 19LLU, 13LLU);
59813+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU);
5965359814 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5965459815 }
5965559816 {
59656- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU);
59817+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU);
5965759818 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5965859819 }
5965959820 {
59660- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 19LLU, 18LLU), 1LLU);
59821+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 1LLU);
5966159822 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5966259823 }
5966359824 {
59664- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 19LLU, 18LLU), 2LLU);
59825+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 2LLU);
5966559826 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5966659827 }
5966759828 // ACCUMULATE ARGUMENTS - END
59668- uint64_t return_to = 18446744073709548049LLU;
59829+ uint64_t return_to = 18446744073709548041LLU;
5966959830 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5967059831 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5967159832 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59674,14 +59835,71 @@
5967459835 state.addr = 587881357514113024LLU; // emitpar___
5967559836 break;
5967659837 }
59677- case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
59838+ case 18446744073709548041LLU: // 99999999HI'''''''''''''''
5967859839 {
59679- state.addr = 18446744073709548050LLU; // 99999999HR'''''''''''''''
59840+ state.addr = 18446744073709548042LLU; // 99999999HJ'''''''''''''''
5968059841 break;
5968159842 }
59682- case 18446744073709548050LLU: // 99999999HR'''''''''''''''
59843+ case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
5968359844 {
5968459845 fprintf(stdout, "%s", "); // result");
59846+ // variable u64 info______ goes out of scope
59847+ // emitted destructur for type u64
59848+ (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 29
59849+ // variable u64 idx_______ goes out of scope
59850+ // emitted destructur for type u64
59851+ (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 28
59852+ // variable u64 parameter_ goes out of scope
59853+ // emitted destructur for type u64
59854+ (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 27
59855+ // variable u64 INDIRECT__ goes out of scope
59856+ // emitted destructur for type u64
59857+ (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 26
59858+ // variable u64 mutable___ goes out of scope
59859+ // emitted destructur for type u64
59860+ (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 25
59861+ // variable u64 init1_____ goes out of scope
59862+ // emitted destructur for type u64
59863+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 24
59864+ // variable type______ typesrc___ goes out of scope
59865+ // emitted destructur for type type______
59866+ // ACCUMULATE ARGUMENTS - BEGIN
59867+ {
59868+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59869+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
59870+ }
59871+ // ACCUMULATE ARGUMENTS - END
59872+ uint64_t return_to = 18446744073709548040LLU;
59873+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
59874+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
59875+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
59876+ heap.data[0].elem1 = heap.data[0].elem0;
59877+ heap.data[0].elem0 = restore;
59878+ state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
59879+ break;
59880+ }
59881+ case 18446744073709548040LLU: // 99999999HH'''''''''''''''
59882+ {
59883+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 23
59884+ state.addr = 18446744073709548057LLU; // 99999999HY'''''''''''''''
59885+ break;
59886+ }
59887+ case 18446744073709548057LLU: // 99999999HY'''''''''''''''
59888+ {
59889+ // variable u64 called____ goes out of scope
59890+ // emitted destructur for type u64
59891+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 22
59892+ // variable u64 sym_______ goes out of scope
59893+ // emitted destructur for type u64
59894+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 21
59895+ // variable u64 id1_______ goes out of scope
59896+ // emitted destructur for type u64
59897+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 20
59898+ state.addr = 18446744073709548073LLU; // 99999999Hn'''''''''''''''
59899+ break;
59900+ }
59901+ case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
59902+ {
5968559903 // parameter-reference resdest___ respar____ goes out of scope
5968659904 // parameter-reference list<resdest___> results___ goes out of scope
5968759905 state.addr = 18446744073709548080LLU; // 99999999Hu'''''''''''''''
@@ -59695,7 +59913,7 @@
5969559913 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5969659914 }
5969759915 // ACCUMULATE ARGUMENTS - END
59698- uint64_t return_to = 18446744073709548047LLU;
59916+ uint64_t return_to = 18446744073709548038LLU;
5969959917 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5970059918 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5970159919 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59704,12 +59922,12 @@
5970459922 state.addr = 839519719621918720LLU; // skipws____
5970559923 break;
5970659924 }
59707- case 18446744073709548047LLU: // 99999999HO'''''''''''''''
59925+ case 18446744073709548038LLU: // 99999999HF'''''''''''''''
5970859926 {
59709- state.addr = 18446744073709548048LLU; // 99999999HP'''''''''''''''
59927+ state.addr = 18446744073709548039LLU; // 99999999HG'''''''''''''''
5971059928 break;
5971159929 }
59712- case 18446744073709548048LLU: // 99999999HP'''''''''''''''
59930+ case 18446744073709548039LLU: // 99999999HG'''''''''''''''
5971359931 {
5971459932 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)));
5971559933 // variable u64 first_____ goes out of scope
@@ -59717,7 +59935,7 @@
5971759935 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 17
5971859936 heap.availilable_size_for_dynamic_objects += 0LLU;
5971959937 heap.availilable_size_for_dynamic_objects += 0LLU;
59720- state.addr = 18446744073709548046LLU; // 99999999HN'''''''''''''''
59938+ state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
5972159939 break;
5972259940 }
5972359941 case 18446744073709548081LLU: // 99999999Hv'''''''''''''''
@@ -59728,7 +59946,7 @@
5972859946 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5972959947 }
5973059948 // ACCUMULATE ARGUMENTS - END
59731- uint64_t return_to = 18446744073709548044LLU;
59949+ uint64_t return_to = 18446744073709548035LLU;
5973259950 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5973359951 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5973459952 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59737,12 +59955,12 @@
5973759955 state.addr = 839519719621918720LLU; // skipws____
5973859956 break;
5973959957 }
59740- case 18446744073709548044LLU: // 99999999HL'''''''''''''''
59958+ case 18446744073709548035LLU: // 99999999HC'''''''''''''''
5974159959 {
59742- state.addr = 18446744073709548045LLU; // 99999999HM'''''''''''''''
59960+ state.addr = 18446744073709548036LLU; // 99999999HD'''''''''''''''
5974359961 break;
5974459962 }
59745- case 18446744073709548045LLU: // 99999999HM'''''''''''''''
59963+ case 18446744073709548036LLU: // 99999999HD'''''''''''''''
5974659964 {
5974759965 {
5974859966 uint64_t arg = 40LLU;
@@ -59753,10 +59971,10 @@
5975359971 LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5975459972 }
5975559973 /*matchsym__*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU));
59756- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548043LLU : 18446744073709548042LLU;
59974+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548034LLU : 18446744073709548033LLU;
5975759975 break;
5975859976 }
59759- case 18446744073709548043LLU: // 99999999HK'''''''''''''''
59977+ case 18446744073709548034LLU: // 99999999HB'''''''''''''''
5976059978 {
5976159979 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
5976259980 // ACCUMULATE ARGUMENTS - BEGIN
@@ -59765,7 +59983,7 @@
5976559983 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5976659984 }
5976759985 // ACCUMULATE ARGUMENTS - END
59768- uint64_t return_to = 18446744073709548040LLU;
59986+ uint64_t return_to = 18446744073709548031LLU;
5976959987 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5977059988 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5977159989 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59774,18 +59992,18 @@
5977459992 state.addr = 839519719621918720LLU; // skipws____
5977559993 break;
5977659994 }
59777- case 18446744073709548040LLU: // 99999999HH'''''''''''''''
59995+ case 18446744073709548031LLU: // 99999999G9'''''''''''''''
5977859996 {
59779- state.addr = 18446744073709548041LLU; // 99999999HI'''''''''''''''
59997+ state.addr = 18446744073709548032LLU; // 99999999H_'''''''''''''''
5978059998 break;
5978159999 }
59782- case 18446744073709548041LLU: // 99999999HI'''''''''''''''
60000+ case 18446744073709548032LLU: // 99999999H_'''''''''''''''
5978360001 {
5978460002 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
59785- state.addr = 18446744073709548042LLU; // 99999999HJ'''''''''''''''
60003+ state.addr = 18446744073709548033LLU; // 99999999HA'''''''''''''''
5978660004 break;
5978760005 }
59788- case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
60006+ case 18446744073709548033LLU: // 99999999HA'''''''''''''''
5978960007 {
5979060008 // variable u64 matchsym__ goes out of scope
5979160009 // emitted destructur for type u64
@@ -59793,10 +60011,10 @@
5979360011 // variable u64 sym_______ goes out of scope
5979460012 // emitted destructur for type u64
5979560013 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 17
59796- state.addr = 18446744073709548046LLU; // 99999999HN'''''''''''''''
60014+ state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
5979760015 break;
5979860016 }
59799- case 18446744073709548046LLU: // 99999999HN'''''''''''''''
60017+ case 18446744073709548037LLU: // 99999999HE'''''''''''''''
5980060018 {
5980160019 // ACCUMULATE ARGUMENTS - BEGIN
5980260020 {
@@ -59804,7 +60022,7 @@
5980460022 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5980560023 }
5980660024 // ACCUMULATE ARGUMENTS - END
59807- uint64_t return_to = 18446744073709548038LLU;
60025+ uint64_t return_to = 18446744073709548029LLU;
5980860026 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5980960027 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5981060028 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59813,12 +60031,12 @@
5981360031 state.addr = 839519719621918720LLU; // skipws____
5981460032 break;
5981560033 }
59816- case 18446744073709548038LLU: // 99999999HF'''''''''''''''
60034+ case 18446744073709548029LLU: // 99999999G7'''''''''''''''
5981760035 {
59818- state.addr = 18446744073709548039LLU; // 99999999HG'''''''''''''''
60036+ state.addr = 18446744073709548030LLU; // 99999999G8'''''''''''''''
5981960037 break;
5982060038 }
59821- case 18446744073709548039LLU: // 99999999HG'''''''''''''''
60039+ case 18446744073709548030LLU: // 99999999G8'''''''''''''''
5982260040 {
5982360041 matchid("}", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 11LLU)));
5982460042 // ACCUMULATE ARGUMENTS - BEGIN
@@ -59867,7 +60085,7 @@
5986760085 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5986860086 }
5986960087 // ACCUMULATE ARGUMENTS - END
59870- uint64_t return_to = 18446744073709548036LLU;
60088+ uint64_t return_to = 18446744073709548027LLU;
5987160089 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
5987260090 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5987360091 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59876,12 +60094,12 @@
5987660094 state.addr = 533581901720365984LLU; // blockclose
5987760095 break;
5987860096 }
59879- case 18446744073709548036LLU: // 99999999HD'''''''''''''''
60097+ case 18446744073709548027LLU: // 99999999G5'''''''''''''''
5988060098 {
59881- state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
60099+ state.addr = 18446744073709548028LLU; // 99999999G6'''''''''''''''
5988260100 break;
5988360101 }
59884- case 18446744073709548037LLU: // 99999999HE'''''''''''''''
60102+ case 18446744073709548028LLU: // 99999999G6'''''''''''''''
5988560103 {
5988660104 // parameter-reference u64 remainheap goes out of scope
5988760105 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainheap at 16
@@ -59931,7 +60149,7 @@
5993160149 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5993260150 }
5993360151 // ACCUMULATE ARGUMENTS - END
59934- uint64_t return_to = 18446744073709548034LLU;
60152+ uint64_t return_to = 18446744073709548025LLU;
5993560153 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5993660154 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5993760155 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59940,12 +60158,12 @@
5994060158 state.addr = 839519719621918720LLU; // skipws____
5994160159 break;
5994260160 }
59943- case 18446744073709548034LLU: // 99999999HB'''''''''''''''
60161+ case 18446744073709548025LLU: // 99999999G3'''''''''''''''
5994460162 {
59945- state.addr = 18446744073709548035LLU; // 99999999HC'''''''''''''''
60163+ state.addr = 18446744073709548026LLU; // 99999999G4'''''''''''''''
5994660164 break;
5994760165 }
59948- case 18446744073709548035LLU: // 99999999HC'''''''''''''''
60166+ case 18446744073709548026LLU: // 99999999G4'''''''''''''''
5994960167 {
5995060168 {
5995160169 uint64_t arg = 0LLU;
@@ -59958,10 +60176,10 @@
5995860176 *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 123LLU;
5995960177
5996060178 /*matchsym__*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU));
59961- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548033LLU : 18446744073709548032LLU;
60179+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548024LLU : 18446744073709548023LLU;
5996260180 break;
5996360181 }
59964- case 18446744073709548033LLU: // 99999999HA'''''''''''''''
60182+ case 18446744073709548024LLU: // 99999999G2'''''''''''''''
5996560183 {
5996660184 // ACCUMULATE ARGUMENTS - BEGIN
5996760185 {
@@ -59989,7 +60207,7 @@
5998960207 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5999060208 }
5999160209 // ACCUMULATE ARGUMENTS - END
59992- uint64_t return_to = 18446744073709548030LLU;
60210+ uint64_t return_to = 18446744073709548021LLU;
5999360211 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
5999460212 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5999560213 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59998,20 +60216,20 @@
5999860216 state.addr = 533581901922699840LLU; // blockopen_
5999960217 break;
6000060218 }
60001- case 18446744073709548030LLU: // 99999999G8'''''''''''''''
60219+ case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
6000260220 {
60003- state.addr = 18446744073709548031LLU; // 99999999G9'''''''''''''''
60221+ state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
6000460222 break;
6000560223 }
60006- case 18446744073709548031LLU: // 99999999G9'''''''''''''''
60224+ case 18446744073709548022LLU: // 99999999G0'''''''''''''''
6000760225 {
6000860226 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU)), &/*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 16LLU)));
6000960227 heap.availilable_size_for_dynamic_objects += 0LLU;
6001060228 heap.availilable_size_for_dynamic_objects += 0LLU;
60011- state.addr = 18446744073709548029LLU; // 99999999G7'''''''''''''''
60229+ state.addr = 18446744073709548020LLU; // 99999999Gy'''''''''''''''
6001260230 break;
6001360231 }
60014- case 18446744073709548032LLU: // 99999999H_'''''''''''''''
60232+ case 18446744073709548023LLU: // 99999999G1'''''''''''''''
6001560233 {
6001660234 {
6001760235 uint64_t arg = 0LLU;
@@ -60023,7 +60241,7 @@
6002360241 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6002460242 }
6002560243 // ACCUMULATE ARGUMENTS - END
60026- uint64_t return_to = 18446744073709548027LLU;
60244+ uint64_t return_to = 18446744073709548018LLU;
6002760245 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6002860246 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6002960247 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60032,21 +60250,21 @@
6003260250 state.addr = 839519719621918720LLU; // skipws____
6003360251 break;
6003460252 }
60035- case 18446744073709548027LLU: // 99999999G5'''''''''''''''
60253+ case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
6003660254 {
60037- state.addr = 18446744073709548028LLU; // 99999999G6'''''''''''''''
60255+ state.addr = 18446744073709548019LLU; // 99999999Gx'''''''''''''''
6003860256 break;
6003960257 }
60040- case 18446744073709548028LLU: // 99999999G6'''''''''''''''
60258+ case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
6004160259 {
6004260260 /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
6004360261 *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 657807020572803072LLU;
6004460262
6004560263 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
60046- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548026LLU : 18446744073709548025LLU;
60264+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548017LLU : 18446744073709548016LLU;
6004760265 break;
6004860266 }
60049- case 18446744073709548026LLU: // 99999999G4'''''''''''''''
60267+ case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
6005060268 {
6005160269 // ACCUMULATE ARGUMENTS - BEGIN
6005260270 {
@@ -60102,7 +60320,7 @@
6010260320 LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6010360321 }
6010460322 // ACCUMULATE ARGUMENTS - END
60105- uint64_t return_to = 18446744073709548023LLU;
60323+ uint64_t return_to = 18446744073709548014LLU;
6010660324 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 13LLU, 0/*address of closure-in-construction*/, 0));
6010760325 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6010860326 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 13LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60111,28 +60329,28 @@
6011160329 state.addr = 787472328605827072LLU; // procif____
6011260330 break;
6011360331 }
60114- case 18446744073709548023LLU: // 99999999G1'''''''''''''''
60332+ case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
6011560333 {
60116- state.addr = 18446744073709548024LLU; // 99999999G2'''''''''''''''
60334+ state.addr = 18446744073709548015LLU; // 99999999Gt'''''''''''''''
6011760335 break;
6011860336 }
60119- case 18446744073709548024LLU: // 99999999G2'''''''''''''''
60337+ case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
6012060338 {
6012160339 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
6012260340 heap.availilable_size_for_dynamic_objects += 0LLU;
6012360341 heap.availilable_size_for_dynamic_objects += 0LLU;
60124- state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
60342+ state.addr = 18446744073709548013LLU; // 99999999Gr'''''''''''''''
6012560343 break;
6012660344 }
60127- case 18446744073709548025LLU: // 99999999G3'''''''''''''''
60345+ case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
6012860346 {
6012960347 *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 512981598149279744LLU;
6013060348
6013160349 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
60132- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548021LLU : 18446744073709548020LLU;
60350+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548012LLU : 18446744073709548011LLU;
6013360351 break;
6013460352 }
60135- case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
60353+ case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
6013660354 {
6013760355 // ACCUMULATE ARGUMENTS - BEGIN
6013860356 {
@@ -60180,7 +60398,7 @@
6018060398 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6018160399 }
6018260400 // ACCUMULATE ARGUMENTS - END
60183- uint64_t return_to = 18446744073709548018LLU;
60401+ uint64_t return_to = 18446744073709548009LLU;
6018460402 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
6018560403 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6018660404 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60189,20 +60407,20 @@
6018960407 state.addr = 787472319973559214LLU; // procaccess
6019060408 break;
6019160409 }
60192- case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
60410+ case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
6019360411 {
60194- state.addr = 18446744073709548019LLU; // 99999999Gx'''''''''''''''
60412+ state.addr = 18446744073709548010LLU; // 99999999Go'''''''''''''''
6019560413 break;
6019660414 }
60197- case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
60415+ case 18446744073709548010LLU: // 99999999Go'''''''''''''''
6019860416 {
6019960417 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
6020060418 heap.availilable_size_for_dynamic_objects += 0LLU;
6020160419 heap.availilable_size_for_dynamic_objects += 0LLU;
60202- state.addr = 18446744073709548017LLU; // 99999999Gv'''''''''''''''
60420+ state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
6020360421 break;
6020460422 }
60205- case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
60423+ case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
6020660424 {
6020760425 *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = 0LLU;
6020860426
@@ -60214,7 +60432,7 @@
6021460432 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6021560433 }
6021660434 // ACCUMULATE ARGUMENTS - END
60217- uint64_t return_to = 18446744073709548015LLU;
60435+ uint64_t return_to = 18446744073709548006LLU;
6021860436 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6021960437 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6022060438 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60223,18 +60441,18 @@
6022360441 state.addr = 839519719621918720LLU; // skipws____
6022460442 break;
6022560443 }
60226- case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
60444+ case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
6022760445 {
60228- state.addr = 18446744073709548016LLU; // 99999999Gu'''''''''''''''
60446+ state.addr = 18446744073709548007LLU; // 99999999Gl'''''''''''''''
6022960447 break;
6023060448 }
60231- case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
60449+ case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
6023260450 {
6023360451 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU));
60234- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548014LLU : 18446744073709548013LLU;
60452+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548005LLU : 18446744073709548004LLU;
6023560453 break;
6023660454 }
60237- case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
60455+ case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
6023860456 {
6023960457 // ACCUMULATE ARGUMENTS - BEGIN
6024060458 {
@@ -60306,7 +60524,7 @@
6030660524 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6030760525 }
6030860526 // ACCUMULATE ARGUMENTS - END
60309- uint64_t return_to = 18446744073709548011LLU;
60527+ uint64_t return_to = 18446744073709548002LLU;
6031060528 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6031160529 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6031260530 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60315,46 +60533,46 @@
6031560533 state.addr = 782701543315110336LLU; // parsecall_
6031660534 break;
6031760535 }
60318- case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
60536+ case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
6031960537 {
60320- state.addr = 18446744073709548012LLU; // 99999999Gq'''''''''''''''
60538+ state.addr = 18446744073709548003LLU; // 99999999Gh'''''''''''''''
6032160539 break;
6032260540 }
60323- case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
60541+ case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
6032460542 {
6032560543 heap.availilable_size_for_dynamic_objects += 0LLU;
6032660544 heap.availilable_size_for_dynamic_objects += 0LLU;
60327- state.addr = 18446744073709548010LLU; // 99999999Go'''''''''''''''
60545+ state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
6032860546 break;
6032960547 }
60330- case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
60548+ case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
6033160549 {
6033260550 {
6033360551 fprintf(stderr, "%s\n", "returning id not implemented");
6033460552 exit(-1);
6033560553 }
60336- state.addr = 18446744073709548010LLU; // 99999999Go'''''''''''''''
60554+ state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
6033760555 break;
6033860556 }
60339- case 18446744073709548010LLU: // 99999999Go'''''''''''''''
60557+ case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
6034060558 {
60341- state.addr = 18446744073709548017LLU; // 99999999Gv'''''''''''''''
60559+ state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
6034260560 break;
6034360561 }
60344- case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
60562+ case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
6034560563 {
60346- state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
60564+ state.addr = 18446744073709548013LLU; // 99999999Gr'''''''''''''''
6034760565 break;
6034860566 }
60349- case 18446744073709548022LLU: // 99999999G0'''''''''''''''
60567+ case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
6035060568 {
6035160569 // variable u64 callee_id_ goes out of scope
6035260570 // emitted destructur for type u64
6035360571 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference callee_id_ at 20
60354- state.addr = 18446744073709548029LLU; // 99999999G7'''''''''''''''
60572+ state.addr = 18446744073709548020LLU; // 99999999Gy'''''''''''''''
6035560573 break;
6035660574 }
60357- case 18446744073709548029LLU: // 99999999G7'''''''''''''''
60575+ case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
6035860576 {
6035960577 // variable u64 sym_______ goes out of scope
6036060578 // emitted destructur for type u64
@@ -60436,7 +60654,7 @@
6043660654 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6043760655 }
6043860656 // ACCUMULATE ARGUMENTS - END
60439- uint64_t return_to = 18446744073709548008LLU;
60657+ uint64_t return_to = 18446744073709547999LLU;
6044060658 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
6044160659 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6044260660 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60445,12 +60663,12 @@
6044560663 state.addr = 533581901922699840LLU; // blockopen_
6044660664 break;
6044760665 }
60448- case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
60666+ case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
6044960667 {
60450- state.addr = 18446744073709548009LLU; // 99999999Gn'''''''''''''''
60668+ state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
6045160669 break;
6045260670 }
60453- case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
60671+ case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
6045460672 {
6045560673 {
6045660674 uint64_t arg = 0LLU;
@@ -60462,7 +60680,7 @@
6046260680 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6046360681 }
6046460682 // ACCUMULATE ARGUMENTS - END
60465- uint64_t return_to = 18446744073709548006LLU;
60683+ uint64_t return_to = 18446744073709547997LLU;
6046660684 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6046760685 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6046860686 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60471,12 +60689,12 @@
6047160689 state.addr = 839519719621918720LLU; // skipws____
6047260690 break;
6047360691 }
60474- case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
60692+ case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
6047560693 {
60476- state.addr = 18446744073709548007LLU; // 99999999Gl'''''''''''''''
60694+ state.addr = 18446744073709547998LLU; // 99999999Gc'''''''''''''''
6047760695 break;
6047860696 }
60479- case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
60697+ case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
6048060698 {
6048160699 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)), stdin);
6048260700 if('(' != (char)getchar())
@@ -60484,15 +60702,15 @@
6048460702 fprintf(stderr, "match failed at char %c\n", (char)40LLU);
6048560703 exit(-1);
6048660704 }
60487- state.addr = 18446744073709548005LLU; // 99999999Gj'''''''''''''''
60705+ state.addr = 18446744073709547996LLU; // 99999999Ga'''''''''''''''
6048860706 break;
6048960707 }
60490- case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
60708+ case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
6049160709 {
6049260710 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
6049360711 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255)
6049460712 {
60495- state.addr = 18446744073709548004LLU; // 99999999Gi'''''''''''''''
60713+ state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
6049660714 break;
6049760715 }
6049860716 // ACCUMULATE ARGUMENTS - BEGIN
@@ -60501,7 +60719,7 @@
6050160719 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6050260720 }
6050360721 // ACCUMULATE ARGUMENTS - END
60504- uint64_t return_to = 18446744073709548002LLU;
60722+ uint64_t return_to = 18446744073709547993LLU;
6050560723 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6050660724 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6050760725 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60510,12 +60728,12 @@
6051060728 state.addr = 839519719621918720LLU; // skipws____
6051160729 break;
6051260730 }
60513- case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
60731+ case 18446744073709547993LLU: // 99999999GY'''''''''''''''
6051460732 {
60515- state.addr = 18446744073709548003LLU; // 99999999Gh'''''''''''''''
60733+ state.addr = 18446744073709547994LLU; // 99999999GZ'''''''''''''''
6051660734 break;
6051760735 }
60518- case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
60736+ case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
6051960737 {
6052060738 {
6052160739 uint64_t arg = 44LLU;
@@ -60530,10 +60748,10 @@
6053060748 LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6053160749 }
6053260750 /*result____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
60533- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548001LLU : 18446744073709548000LLU;
60751+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547992LLU : 18446744073709547991LLU;
6053460752 break;
6053560753 }
60536- case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
60754+ case 18446744073709547992LLU: // 99999999GX'''''''''''''''
6053760755 {
6053860756 {
6053960757 uint64_t arg = 0LLU;
@@ -60545,7 +60763,7 @@
6054560763 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6054660764 }
6054760765 // ACCUMULATE ARGUMENTS - END
60548- uint64_t return_to = 18446744073709547998LLU;
60766+ uint64_t return_to = 18446744073709547989LLU;
6054960767 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6055060768 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6055160769 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60554,12 +60772,12 @@
6055460772 state.addr = 839519719621918720LLU; // skipws____
6055560773 break;
6055660774 }
60557- case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
60775+ case 18446744073709547989LLU: // 99999999GU'''''''''''''''
6055860776 {
60559- state.addr = 18446744073709547999LLU; // 99999999Gd'''''''''''''''
60777+ state.addr = 18446744073709547990LLU; // 99999999GV'''''''''''''''
6056060778 break;
6056160779 }
60562- case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
60780+ case 18446744073709547990LLU: // 99999999GV'''''''''''''''
6056360781 {
6056460782 /*resultid__*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
6056560783 {
@@ -60574,10 +60792,10 @@
6057460792 };
6057560793 *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = arg;
6057660794 }
60577- state.addr = 18446744073709547996LLU; // 99999999Ga'''''''''''''''
60795+ state.addr = 18446744073709547987LLU; // 99999999GS'''''''''''''''
6057860796 break;
6057960797 }
60580- case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
60798+ case 18446744073709547987LLU: // 99999999GS'''''''''''''''
6058160799 {
6058260800 {
6058360801 uint64_t arg = 0LLU;
@@ -60657,7 +60875,7 @@
6065760875 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6065860876 }
6065960877 // ACCUMULATE ARGUMENTS - END
60660- uint64_t return_to = 18446744073709547994LLU;
60878+ uint64_t return_to = 18446744073709547985LLU;
6066160879 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
6066260880 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6066360881 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60666,17 +60884,17 @@
6066660884 state.addr = 604790753280317473LLU; // findvarref
6066760885 break;
6066860886 }
60669- case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
60887+ case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
6067060888 {
60671- state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
60889+ state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
6067260890 break;
6067360891 }
60674- case 18446744073709547995LLU: // 99999999G$'''''''''''''''
60892+ case 18446744073709547986LLU: // 99999999GR'''''''''''''''
6067560893 {
60676- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547993LLU : 18446744073709547992LLU;
60894+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547984LLU : 18446744073709547983LLU;
6067760895 break;
6067860896 }
60679- case 18446744073709547993LLU: // 99999999GY'''''''''''''''
60897+ case 18446744073709547984LLU: // 99999999GP'''''''''''''''
6068060898 {
6068160899 // ACCUMULATE ARGUMENTS - BEGIN
6068260900 {
@@ -60684,7 +60902,7 @@
6068460902 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6068560903 }
6068660904 // ACCUMULATE ARGUMENTS - END
60687- uint64_t return_to = 18446744073709547990LLU;
60905+ uint64_t return_to = 18446744073709547981LLU;
6068860906 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6068960907 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6069060908 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60693,12 +60911,12 @@
6069360911 state.addr = 819847183515949359LLU; // reportinit
6069460912 break;
6069560913 }
60696- case 18446744073709547990LLU: // 99999999GV'''''''''''''''
60914+ case 18446744073709547981LLU: // 99999999GM'''''''''''''''
6069760915 {
60698- state.addr = 18446744073709547991LLU; // 99999999GW'''''''''''''''
60916+ state.addr = 18446744073709547982LLU; // 99999999GN'''''''''''''''
6069960917 break;
6070060918 }
60701- case 18446744073709547991LLU: // 99999999GW'''''''''''''''
60919+ case 18446744073709547982LLU: // 99999999GN'''''''''''''''
6070260920 {
6070360921 fprintf(stderr, "%s", "produce-argument ");
6070460922 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 30LLU, 21LLU));
@@ -60709,10 +60927,10 @@
6070960927 }
6071060928 heap.availilable_size_for_dynamic_objects += 0LLU;
6071160929 heap.availilable_size_for_dynamic_objects += 0LLU;
60712- state.addr = 18446744073709547989LLU; // 99999999GU'''''''''''''''
60930+ state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
6071360931 break;
6071460932 }
60715- case 18446744073709547992LLU: // 99999999GX'''''''''''''''
60933+ case 18446744073709547983LLU: // 99999999GO'''''''''''''''
6071660934 {
6071760935 // ACCUMULATE ARGUMENTS - BEGIN
6071860936 {
@@ -60732,7 +60950,7 @@
6073260950 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6073360951 }
6073460952 // ACCUMULATE ARGUMENTS - END
60735- uint64_t return_to = 18446744073709547987LLU;
60953+ uint64_t return_to = 18446744073709547978LLU;
6073660954 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6073760955 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6073860956 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60741,17 +60959,17 @@
6074160959 state.addr = 660220432971388961LLU; // initvarref
6074260960 break;
6074360961 }
60744- case 18446744073709547987LLU: // 99999999GS'''''''''''''''
60962+ case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
6074560963 {
60746- state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
60964+ state.addr = 18446744073709547979LLU; // 99999999GK'''''''''''''''
6074760965 break;
6074860966 }
60749- case 18446744073709547988LLU: // 99999999GT'''''''''''''''
60967+ case 18446744073709547979LLU: // 99999999GK'''''''''''''''
6075060968 {
60751- state.addr = 18446744073709547989LLU; // 99999999GU'''''''''''''''
60969+ state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
6075260970 break;
6075360971 }
60754- case 18446744073709547989LLU: // 99999999GU'''''''''''''''
60972+ case 18446744073709547980LLU: // 99999999GL'''''''''''''''
6075560973 {
6075660974 {
6075760975 uint64_t arg = 0LLU;
@@ -60784,7 +61002,7 @@
6078461002 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6078561003 }
6078661004 // ACCUMULATE ARGUMENTS - END
60787- uint64_t return_to = 18446744073709547985LLU;
61005+ uint64_t return_to = 18446744073709547976LLU;
6078861006 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6078961007 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6079061008 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60793,12 +61011,12 @@
6079361011 state.addr = 734295421765213120LLU; // mutassert_
6079461012 break;
6079561013 }
60796- case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
61014+ case 18446744073709547976LLU: // 99999999GH'''''''''''''''
6079761015 {
60798- state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
61016+ state.addr = 18446744073709547977LLU; // 99999999GI'''''''''''''''
6079961017 break;
6080061018 }
60801- case 18446744073709547986LLU: // 99999999GR'''''''''''''''
61019+ case 18446744073709547977LLU: // 99999999GI'''''''''''''''
6080261020 {
6080361021 {
6080461022 uint64_t arg = /*resultid__*/*LOCAL_ACCESS(heap.data, 32LLU, 21LLU);
@@ -60821,15 +61039,15 @@
6082161039 tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 34LLU, 32LLU));
6082261040 *LOCAL_ACCESS(heap.data, 34LLU, 33LLU) = arg;
6082361041 }
60824- state.addr = 18446744073709547983LLU; // 99999999GO'''''''''''''''
61042+ state.addr = 18446744073709547974LLU; // 99999999GF'''''''''''''''
6082561043 break;
6082661044 }
60827- case 18446744073709547983LLU: // 99999999GO'''''''''''''''
61045+ case 18446744073709547974LLU: // 99999999GF'''''''''''''''
6082861046 {
60829- state.addr = !list_push_move(&heap, &/*block_____*/*LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &/*varlist___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547982LLU : 18446744073709547981LLU;
61047+ state.addr = !list_push_move(&heap, &/*block_____*/*LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &/*varlist___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547973LLU : 18446744073709547972LLU;
6083061048 break;
6083161049 }
60832- case 18446744073709547982LLU: // 99999999GN'''''''''''''''
61050+ case 18446744073709547973LLU: // 99999999GE'''''''''''''''
6083361051 {
6083461052 {
6083561053 uint64_t arg = *LOCAL_ACCESS(heap.data, 34LLU, 33LLU);
@@ -60841,7 +61059,7 @@
6084161059 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6084261060 }
6084361061 // ACCUMULATE ARGUMENTS - END
60844- uint64_t return_to = 18446744073709547979LLU;
61062+ uint64_t return_to = 18446744073709547970LLU;
6084561063 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6084661064 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6084761065 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60850,12 +61068,12 @@
6085061068 state.addr = 819847183515949359LLU; // reportinit
6085161069 break;
6085261070 }
60853- case 18446744073709547979LLU: // 99999999GK'''''''''''''''
61071+ case 18446744073709547970LLU: // 99999999GB'''''''''''''''
6085461072 {
60855- state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
61073+ state.addr = 18446744073709547971LLU; // 99999999GC'''''''''''''''
6085661074 break;
6085761075 }
60858- case 18446744073709547980LLU: // 99999999GL'''''''''''''''
61076+ case 18446744073709547971LLU: // 99999999GC'''''''''''''''
6085961077 {
6086061078 fprintf(stderr, "%s", "pushing block ");
6086161079 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 35LLU, 21LLU));
@@ -60872,7 +61090,7 @@
6087261090 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6087361091 }
6087461092 // ACCUMULATE ARGUMENTS - END
60875- uint64_t return_to = 18446744073709547978LLU;
61093+ uint64_t return_to = 18446744073709547969LLU;
6087661094 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6087761095 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6087861096 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60881,20 +61099,20 @@
6088161099 state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
6088261100 break;
6088361101 }
60884- case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
61102+ case 18446744073709547969LLU: // 99999999GA'''''''''''''''
6088561103 {
6088661104 (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference block_____ at 35
6088761105 heap.availilable_size_for_dynamic_objects += 0LLU;
6088861106 heap.availilable_size_for_dynamic_objects += 0LLU;
60889- state.addr = 18446744073709547977LLU; // 99999999GI'''''''''''''''
61107+ state.addr = 18446744073709547968LLU; // 99999999G_'''''''''''''''
6089061108 break;
6089161109 }
60892- case 18446744073709547981LLU: // 99999999GM'''''''''''''''
61110+ case 18446744073709547972LLU: // 99999999GD'''''''''''''''
6089361111 {
60894- state.addr = 18446744073709547977LLU; // 99999999GI'''''''''''''''
61112+ state.addr = 18446744073709547968LLU; // 99999999G_'''''''''''''''
6089561113 break;
6089661114 }
60897- case 18446744073709547977LLU: // 99999999GI'''''''''''''''
61115+ case 18446744073709547968LLU: // 99999999G_'''''''''''''''
6089861116 {
6089961117 // variable varentry__ block_____ goes out of scope
6090061118 // (uninitialized -> no destructor-call)
@@ -60902,10 +61120,10 @@
6090261120 // variable u64 id2_______ goes out of scope
6090361121 // (uninitialized -> no destructor-call)
6090461122 (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id2_______ at 33
60905- state.addr = 18446744073709547984LLU; // 99999999GP'''''''''''''''
61123+ state.addr = 18446744073709547975LLU; // 99999999GG'''''''''''''''
6090661124 break;
6090761125 }
60908- case 18446744073709547984LLU: // 99999999GP'''''''''''''''
61126+ case 18446744073709547975LLU: // 99999999GG'''''''''''''''
6090961127 {
6091061128 {
6091161129 uint64_t arg = 0;
@@ -60918,15 +61136,15 @@
6091861136 tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 33LLU, 24LLU));
6091961137 *LOCAL_ACCESS(heap.data, 33LLU, 32LLU) = arg;
6092061138 }
60921- state.addr = 18446744073709547975LLU; // 99999999GG'''''''''''''''
61139+ state.addr = 18446744073709547966LLU; // 99999999F8'''''''''''''''
6092261140 break;
6092361141 }
60924- case 18446744073709547975LLU: // 99999999GG'''''''''''''''
61142+ case 18446744073709547966LLU: // 99999999F8'''''''''''''''
6092561143 {
60926- state.addr = !list_push_move(&heap, &/*assignto__*/*LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &/*newresults*/*LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547974LLU : 18446744073709547973LLU;
61144+ state.addr = !list_push_move(&heap, &/*assignto__*/*LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &/*newresults*/*LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547965LLU : 18446744073709547964LLU;
6092761145 break;
6092861146 }
60929- case 18446744073709547974LLU: // 99999999GF'''''''''''''''
61147+ case 18446744073709547965LLU: // 99999999F7'''''''''''''''
6093061148 {
6093161149 {
6093261150 uint64_t arg = *LOCAL_ACCESS(heap.data, 33LLU, 32LLU);
@@ -60938,7 +61156,7 @@
6093861156 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6093961157 }
6094061158 // ACCUMULATE ARGUMENTS - END
60941- uint64_t return_to = 18446744073709547971LLU;
61159+ uint64_t return_to = 18446744073709547962LLU;
6094261160 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6094361161 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6094461162 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60947,12 +61165,12 @@
6094761165 state.addr = 819847183515949359LLU; // reportinit
6094861166 break;
6094961167 }
60950- case 18446744073709547971LLU: // 99999999GC'''''''''''''''
61168+ case 18446744073709547962LLU: // 99999999F4'''''''''''''''
6095161169 {
60952- state.addr = 18446744073709547972LLU; // 99999999GD'''''''''''''''
61170+ state.addr = 18446744073709547963LLU; // 99999999F5'''''''''''''''
6095361171 break;
6095461172 }
60955- case 18446744073709547972LLU: // 99999999GD'''''''''''''''
61173+ case 18446744073709547963LLU: // 99999999F5'''''''''''''''
6095661174 {
6095761175 fprintf(stderr, "%s", "pushing assignment-destination ");
6095861176 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 34LLU, 21LLU));
@@ -60969,7 +61187,7 @@
6096961187 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6097061188 }
6097161189 // ACCUMULATE ARGUMENTS - END
60972- uint64_t return_to = 18446744073709547970LLU;
61190+ uint64_t return_to = 18446744073709547961LLU;
6097361191 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6097461192 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6097561193 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60978,28 +61196,28 @@
6097861196 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
6097961197 break;
6098061198 }
60981- case 18446744073709547970LLU: // 99999999GB'''''''''''''''
61199+ case 18446744073709547961LLU: // 99999999F3'''''''''''''''
6098261200 {
6098361201 (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference assignto__ at 34
6098461202 heap.availilable_size_for_dynamic_objects += 0LLU;
6098561203 heap.availilable_size_for_dynamic_objects += 0LLU;
60986- state.addr = 18446744073709547969LLU; // 99999999GA'''''''''''''''
61204+ state.addr = 18446744073709547960LLU; // 99999999F2'''''''''''''''
6098761205 break;
6098861206 }
60989- case 18446744073709547973LLU: // 99999999GE'''''''''''''''
61207+ case 18446744073709547964LLU: // 99999999F6'''''''''''''''
6099061208 {
60991- state.addr = 18446744073709547969LLU; // 99999999GA'''''''''''''''
61209+ state.addr = 18446744073709547960LLU; // 99999999F2'''''''''''''''
6099261210 break;
6099361211 }
60994- case 18446744073709547969LLU: // 99999999GA'''''''''''''''
61212+ case 18446744073709547960LLU: // 99999999F2'''''''''''''''
6099561213 {
6099661214 // variable resdest___ assignto__ goes out of scope
6099761215 // (uninitialized -> no destructor-call)
6099861216 (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference assignto__ at 33
60999- state.addr = 18446744073709547976LLU; // 99999999GH'''''''''''''''
61217+ state.addr = 18446744073709547967LLU; // 99999999F9'''''''''''''''
6100061218 break;
6100161219 }
61002- case 18446744073709547976LLU: // 99999999GH'''''''''''''''
61220+ case 18446744073709547967LLU: // 99999999F9'''''''''''''''
6100361221 {
6100461222 // variable u64 callee_id_ goes out of scope
6100561223 // emitted destructur for type u64
@@ -61031,10 +61249,10 @@
6103161249 // variable type______ type______ goes out of scope
6103261250 // (uninitialized -> no destructor-call)
6103361251 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 23
61034- state.addr = 18446744073709547997LLU; // 99999999Gb'''''''''''''''
61252+ state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
6103561253 break;
6103661254 }
61037- case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
61255+ case 18446744073709547988LLU: // 99999999GT'''''''''''''''
6103861256 {
6103961257 // ACCUMULATE ARGUMENTS - BEGIN
6104061258 {
@@ -61042,7 +61260,7 @@
6104261260 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6104361261 }
6104461262 // ACCUMULATE ARGUMENTS - END
61045- uint64_t return_to = 18446744073709547967LLU;
61263+ uint64_t return_to = 18446744073709547958LLU;
6104661264 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6104761265 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6104861266 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61051,32 +61269,32 @@
6105161269 state.addr = 839519719621918720LLU; // skipws____
6105261270 break;
6105361271 }
61054- case 18446744073709547967LLU: // 99999999F9'''''''''''''''
61272+ case 18446744073709547958LLU: // 99999999F0'''''''''''''''
6105561273 {
61056- state.addr = 18446744073709547968LLU; // 99999999G_'''''''''''''''
61274+ state.addr = 18446744073709547959LLU; // 99999999F1'''''''''''''''
6105761275 break;
6105861276 }
61059- case 18446744073709547968LLU: // 99999999G_'''''''''''''''
61277+ case 18446744073709547959LLU: // 99999999F1'''''''''''''''
6106061278 {
6106161279 /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /*separator_*/*LOCAL_ACCESS(heap.data, 22LLU, 18LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
61062- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547966LLU : 18446744073709547965LLU;
61280+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547957LLU : 18446744073709547956LLU;
6106361281 break;
6106461282 }
61065- case 18446744073709547966LLU: // 99999999F8'''''''''''''''
61283+ case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
6106661284 {
6106761285 /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
61068- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547964LLU : 18446744073709547963LLU;
61286+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547955LLU : 18446744073709547954LLU;
6106961287 break;
6107061288 }
61071- case 18446744073709547964LLU: // 99999999F6'''''''''''''''
61289+ case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
6107261290 {
6107361291 ungetc(0, stdin);
6107461292 heap.availilable_size_for_dynamic_objects += 0LLU;
6107561293 heap.availilable_size_for_dynamic_objects += 0LLU;
61076- state.addr = 18446744073709547962LLU; // 99999999F4'''''''''''''''
61294+ state.addr = 18446744073709547953LLU; // 99999999Fv'''''''''''''''
6107761295 break;
6107861296 }
61079- case 18446744073709547963LLU: // 99999999F5'''''''''''''''
61297+ case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
6108061298 {
6108161299 // ACCUMULATE ARGUMENTS - BEGIN
6108261300 {
@@ -61084,7 +61302,7 @@
6108461302 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6108561303 }
6108661304 // ACCUMULATE ARGUMENTS - END
61087- uint64_t return_to = 18446744073709547960LLU;
61305+ uint64_t return_to = 18446744073709547951LLU;
6108861306 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6108961307 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6109061308 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61093,12 +61311,12 @@
6109361311 state.addr = 819847183515949359LLU; // reportinit
6109461312 break;
6109561313 }
61096- case 18446744073709547960LLU: // 99999999F2'''''''''''''''
61314+ case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
6109761315 {
61098- state.addr = 18446744073709547961LLU; // 99999999F3'''''''''''''''
61316+ state.addr = 18446744073709547952LLU; // 99999999Fu'''''''''''''''
6109961317 break;
6110061318 }
61101- case 18446744073709547961LLU: // 99999999F3'''''''''''''''
61319+ case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
6110261320 {
6110361321 fprintf(stderr, "%s", "expected ',' or ')' but found ");
6110461322 putc((char)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stderr);
@@ -61106,15 +61324,15 @@
6110661324 fprintf(stderr, "%s\n", "");
6110761325 exit(-1);
6110861326 }
61109- state.addr = 18446744073709547962LLU; // 99999999F4'''''''''''''''
61327+ state.addr = 18446744073709547953LLU; // 99999999Fv'''''''''''''''
6111061328 break;
6111161329 }
61112- case 18446744073709547962LLU: // 99999999F4'''''''''''''''
61330+ case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
6111361331 {
61114- state.addr = 18446744073709547965LLU; // 99999999F7'''''''''''''''
61332+ state.addr = 18446744073709547956LLU; // 99999999Fy'''''''''''''''
6111561333 break;
6111661334 }
61117- case 18446744073709547965LLU: // 99999999F7'''''''''''''''
61335+ case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
6111861336 {
6111961337 // variable u64 resultid__ goes out of scope
6112061338 // emitted destructur for type u64
@@ -61121,16 +61339,16 @@
6112161339 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultid__ at 22
6112261340 heap.availilable_size_for_dynamic_objects += 0LLU;
6112361341 heap.availilable_size_for_dynamic_objects += 0LLU;
61124- state.addr = 18446744073709547959LLU; // 99999999F1'''''''''''''''
61342+ state.addr = 18446744073709547950LLU; // 99999999Fs'''''''''''''''
6112561343 break;
6112661344 }
61127- case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
61345+ case 18446744073709547991LLU: // 99999999GW'''''''''''''''
6112861346 {
6112961347 ungetc(0, stdin);
61130- state.addr = 18446744073709547959LLU; // 99999999F1'''''''''''''''
61348+ state.addr = 18446744073709547950LLU; // 99999999Fs'''''''''''''''
6113161349 break;
6113261350 }
61133- case 18446744073709547959LLU: // 99999999F1'''''''''''''''
61351+ case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
6113461352 {
6113561353 // variable u64 result____ goes out of scope
6113661354 // emitted destructur for type u64
@@ -61141,10 +61359,10 @@
6114161359 // variable u64 separator_ goes out of scope
6114261360 // emitted destructur for type u64
6114361361 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference separator_ at 19
61144- state.addr = 18446744073709548005LLU; // 99999999Gj'''''''''''''''
61362+ state.addr = 18446744073709547996LLU; // 99999999Ga'''''''''''''''
6114561363 break;
6114661364 }
61147- case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
61365+ case 18446744073709547995LLU: // 99999999G$'''''''''''''''
6114861366 {
6114961367 /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
6115061368 list_reverse(heap.data, &/*newresults*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU));
@@ -61206,7 +61424,7 @@
6120661424 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6120761425 }
6120861426 // ACCUMULATE ARGUMENTS - END
61209- uint64_t return_to = 18446744073709547956LLU;
61427+ uint64_t return_to = 18446744073709547947LLU;
6121061428 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
6121161429 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6121261430 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61215,17 +61433,17 @@
6121561433 state.addr = 533581901720365984LLU; // blockclose
6121661434 break;
6121761435 }
61218- case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
61436+ case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
6121961437 {
61220- state.addr = 18446744073709547957LLU; // 99999999Fz'''''''''''''''
61438+ state.addr = 18446744073709547948LLU; // 99999999Fq'''''''''''''''
6122161439 break;
6122261440 }
61223- case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
61441+ case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
6122461442 {
61225- state.addr = /*tmpresults*/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547955LLU : 18446744073709547954LLU;
61443+ state.addr = /*tmpresults*/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547946LLU : 18446744073709547945LLU;
6122661444 break;
6122761445 }
61228- case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
61446+ case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
6122961447 {
6123061448 fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
6123161449 {
@@ -61232,10 +61450,10 @@
6123261450 fprintf(stderr, "%s\n", "");
6123361451 exit(-1);
6123461452 }
61235- state.addr = 18446744073709547954LLU; // 99999999Fw'''''''''''''''
61453+ state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
6123661454 break;
6123761455 }
61238- case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
61456+ case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
6123961457 {
6124061458 {
6124161459 uint64_t arg = 0LLU;
@@ -61242,10 +61460,10 @@
6124261460 LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6124361461 }
6124461462 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) != /*ds________*/*LOCAL_ACCESS(heap.data, 22LLU, 18LLU);
61245- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547953LLU : 18446744073709547952LLU;
61463+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547944LLU : 18446744073709547943LLU;
6124661464 break;
6124761465 }
61248- case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
61466+ case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
6124961467 {
6125061468 fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
6125161469 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61254,7 +61472,7 @@
6125461472 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6125561473 }
6125661474 // ACCUMULATE ARGUMENTS - END
61257- uint64_t return_to = 18446744073709547950LLU;
61475+ uint64_t return_to = 18446744073709547941LLU;
6125861476 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6125961477 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6126061478 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61263,12 +61481,12 @@
6126361481 state.addr = 819847183517274112LLU; // reportnr__
6126461482 break;
6126561483 }
61266- case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
61484+ case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
6126761485 {
61268- state.addr = 18446744073709547951LLU; // 99999999Ft'''''''''''''''
61486+ state.addr = 18446744073709547942LLU; // 99999999Fk'''''''''''''''
6126961487 break;
6127061488 }
61271- case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
61489+ case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
6127261490 {
6127361491 fprintf(stderr, "%s", " != ");
6127461492 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61277,7 +61495,7 @@
6127761495 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6127861496 }
6127961497 // ACCUMULATE ARGUMENTS - END
61280- uint64_t return_to = 18446744073709547948LLU;
61498+ uint64_t return_to = 18446744073709547939LLU;
6128161499 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6128261500 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6128361501 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61286,27 +61504,27 @@
6128661504 state.addr = 819847183517274112LLU; // reportnr__
6128761505 break;
6128861506 }
61289- case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
61507+ case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
6129061508 {
61291- state.addr = 18446744073709547949LLU; // 99999999Fr'''''''''''''''
61509+ state.addr = 18446744073709547940LLU; // 99999999Fi'''''''''''''''
6129261510 break;
6129361511 }
61294- case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
61512+ case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
6129561513 {
6129661514 {
6129761515 fprintf(stderr, "%s\n", "");
6129861516 exit(-1);
6129961517 }
61300- state.addr = 18446744073709547952LLU; // 99999999Fu'''''''''''''''
61518+ state.addr = 18446744073709547943LLU; // 99999999Fl'''''''''''''''
6130161519 break;
6130261520 }
61303- case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
61521+ case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
6130461522 {
6130561523 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainsize*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 14LLU)) != /*rs________*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
61306- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547947LLU : 18446744073709547946LLU;
61524+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547938LLU : 18446744073709547937LLU;
6130761525 break;
6130861526 }
61309- case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
61527+ case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
6131061528 {
6131161529 fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
6131261530 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61315,7 +61533,7 @@
6131561533 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6131661534 }
6131761535 // ACCUMULATE ARGUMENTS - END
61318- uint64_t return_to = 18446744073709547944LLU;
61536+ uint64_t return_to = 18446744073709547935LLU;
6131961537 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6132061538 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6132161539 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61324,12 +61542,12 @@
6132461542 state.addr = 819847183517274112LLU; // reportnr__
6132561543 break;
6132661544 }
61327- case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
61545+ case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
6132861546 {
61329- state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
61547+ state.addr = 18446744073709547936LLU; // 99999999Fe'''''''''''''''
6133061548 break;
6133161549 }
61332- case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
61550+ case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
6133361551 {
6133461552 fprintf(stderr, "%s", " != ");
6133561553 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61338,7 +61556,7 @@
6133861556 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6133961557 }
6134061558 // ACCUMULATE ARGUMENTS - END
61341- uint64_t return_to = 18446744073709547942LLU;
61559+ uint64_t return_to = 18446744073709547933LLU;
6134261560 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6134361561 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6134461562 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61347,27 +61565,27 @@
6134761565 state.addr = 819847183517274112LLU; // reportnr__
6134861566 break;
6134961567 }
61350- case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
61568+ case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
6135161569 {
61352- state.addr = 18446744073709547943LLU; // 99999999Fl'''''''''''''''
61570+ state.addr = 18446744073709547934LLU; // 99999999Fc'''''''''''''''
6135361571 break;
6135461572 }
61355- case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
61573+ case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
6135661574 {
6135761575 {
6135861576 fprintf(stderr, "%s\n", "");
6135961577 exit(-1);
6136061578 }
61361- state.addr = 18446744073709547946LLU; // 99999999Fo'''''''''''''''
61579+ state.addr = 18446744073709547937LLU; // 99999999Ff'''''''''''''''
6136261580 break;
6136361581 }
61364- case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
61582+ case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
6136561583 {
6136661584 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 15LLU)) != /*rh________*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU);
61367- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547941LLU : 18446744073709547940LLU;
61585+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547932LLU : 18446744073709547931LLU;
6136861586 break;
6136961587 }
61370- case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
61588+ case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
6137161589 {
6137261590 fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch ");
6137361591 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61376,7 +61594,7 @@
6137661594 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6137761595 }
6137861596 // ACCUMULATE ARGUMENTS - END
61379- uint64_t return_to = 18446744073709547938LLU;
61597+ uint64_t return_to = 18446744073709547929LLU;
6138061598 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6138161599 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6138261600 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61385,12 +61603,12 @@
6138561603 state.addr = 819847183517274112LLU; // reportnr__
6138661604 break;
6138761605 }
61388- case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
61606+ case 18446744073709547929LLU: // 99999999FY'''''''''''''''
6138961607 {
61390- state.addr = 18446744073709547939LLU; // 99999999Fh'''''''''''''''
61608+ state.addr = 18446744073709547930LLU; // 99999999FZ'''''''''''''''
6139161609 break;
6139261610 }
61393- case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
61611+ case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
6139461612 {
6139561613 fprintf(stderr, "%s", " != ");
6139661614 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61399,7 +61617,7 @@
6139961617 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6140061618 }
6140161619 // ACCUMULATE ARGUMENTS - END
61402- uint64_t return_to = 18446744073709547936LLU;
61620+ uint64_t return_to = 18446744073709547927LLU;
6140361621 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6140461622 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6140561623 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61408,21 +61626,21 @@
6140861626 state.addr = 819847183517274112LLU; // reportnr__
6140961627 break;
6141061628 }
61411- case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
61629+ case 18446744073709547927LLU: // 99999999FW'''''''''''''''
6141261630 {
61413- state.addr = 18446744073709547937LLU; // 99999999Ff'''''''''''''''
61631+ state.addr = 18446744073709547928LLU; // 99999999FX'''''''''''''''
6141461632 break;
6141561633 }
61416- case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
61634+ case 18446744073709547928LLU: // 99999999FX'''''''''''''''
6141761635 {
6141861636 {
6141961637 fprintf(stderr, "%s\n", "");
6142061638 exit(-1);
6142161639 }
61422- state.addr = 18446744073709547940LLU; // 99999999Fi'''''''''''''''
61640+ state.addr = 18446744073709547931LLU; // 99999999F$'''''''''''''''
6142361641 break;
6142461642 }
61425- case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
61643+ case 18446744073709547931LLU: // 99999999F$'''''''''''''''
6142661644 {
6142761645 // variable u64 buf_______ goes out of scope
6142861646 // emitted destructur for type u64
@@ -61436,10 +61654,10 @@
6143661654 // variable u64 ds________ goes out of scope
6143761655 // emitted destructur for type u64
6143861656 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ds________ at 19
61439- state.addr = 18446744073709547958LLU; // 99999999F0'''''''''''''''
61657+ state.addr = 18446744073709547949LLU; // 99999999Fr'''''''''''''''
6144061658 break;
6144161659 }
61442- case 18446744073709547958LLU: // 99999999F0'''''''''''''''
61660+ case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
6144361661 {
6144461662 // ACCUMULATE ARGUMENTS - BEGIN
6144561663 {
@@ -61447,7 +61665,7 @@
6144761665 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6144861666 }
6144961667 // ACCUMULATE ARGUMENTS - END
61450- uint64_t return_to = 18446744073709547934LLU;
61668+ uint64_t return_to = 18446744073709547925LLU;
6145161669 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6145261670 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6145361671 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61456,12 +61674,12 @@
6145661674 state.addr = 839519719621918720LLU; // skipws____
6145761675 break;
6145861676 }
61459- case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
61677+ case 18446744073709547925LLU: // 99999999FU'''''''''''''''
6146061678 {
61461- state.addr = 18446744073709547935LLU; // 99999999Fd'''''''''''''''
61679+ state.addr = 18446744073709547926LLU; // 99999999FV'''''''''''''''
6146261680 break;
6146361681 }
61464- case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
61682+ case 18446744073709547926LLU: // 99999999FV'''''''''''''''
6146561683 {
6146661684 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
6146761685 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61534,7 +61752,7 @@
6153461752 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6153561753 }
6153661754 // ACCUMULATE ARGUMENTS - END
61537- uint64_t return_to = 18446744073709547932LLU;
61755+ uint64_t return_to = 18446744073709547923LLU;
6153861756 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6153961757 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6154061758 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61543,23 +61761,23 @@
6154361761 state.addr = 787472338545441824LLU; // procrvalue
6154461762 break;
6154561763 }
61546- case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
61764+ case 18446744073709547923LLU: // 99999999FS'''''''''''''''
6154761765 {
61548- state.addr = 18446744073709547933LLU; // 99999999Fb'''''''''''''''
61766+ state.addr = 18446744073709547924LLU; // 99999999FT'''''''''''''''
6154961767 break;
6155061768 }
61551- case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
61769+ case 18446744073709547924LLU: // 99999999FT'''''''''''''''
6155261770 {
6155361771 // variable list<resdest___> newresults goes out of scope
6155461772 // emitted destructur for type list<resdest___>
61555- state.addr = 18446744073709547930LLU; // 99999999FZ'''''''''''''''
61773+ state.addr = 18446744073709547921LLU; // 99999999FQ'''''''''''''''
6155661774 break;
6155761775 }
61558- case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
61776+ case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
6155961777 {
6156061778 if(!*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/*list*/)
6156161779 {
61562- state.addr = 18446744073709547931LLU; // 99999999F$'''''''''''''''
61780+ state.addr = 18446744073709547922LLU; // 99999999FR'''''''''''''''
6156361781 break;
6156461782 }
6156561783 // temporary list-element
@@ -61573,7 +61791,7 @@
6157361791 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6157461792 }
6157561793 // ACCUMULATE ARGUMENTS - END
61576- uint64_t return_to = 18446744073709547929LLU;
61794+ uint64_t return_to = 18446744073709547920LLU;
6157761795 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6157861796 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6157961797 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61582,26 +61800,26 @@
6158261800 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
6158361801 break;
6158461802 }
61585- case 18446744073709547929LLU: // 99999999FY'''''''''''''''
61803+ case 18446744073709547920LLU: // 99999999FP'''''''''''''''
6158661804 {
6158761805 // RELEASE temporary destructor-variable
6158861806 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
61589- state.addr = 18446744073709547930LLU; // 99999999FZ'''''''''''''''
61807+ state.addr = 18446744073709547921LLU; // 99999999FQ'''''''''''''''
6159061808 break;
6159161809 }
61592- case 18446744073709547931LLU: // 99999999F$'''''''''''''''
61810+ case 18446744073709547922LLU: // 99999999FR'''''''''''''''
6159361811 {
6159461812 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 18
6159561813 // variable list<resdest___> tmpresults goes out of scope
6159661814 // emitted destructur for type list<resdest___>
61597- state.addr = 18446744073709547927LLU; // 99999999FW'''''''''''''''
61815+ state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
6159861816 break;
6159961817 }
61600- case 18446744073709547927LLU: // 99999999FW'''''''''''''''
61818+ case 18446744073709547918LLU: // 99999999FN'''''''''''''''
6160161819 {
6160261820 if(!*LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/*list*/)
6160361821 {
61604- state.addr = 18446744073709547928LLU; // 99999999FX'''''''''''''''
61822+ state.addr = 18446744073709547919LLU; // 99999999FO'''''''''''''''
6160561823 break;
6160661824 }
6160761825 // temporary list-element
@@ -61615,7 +61833,7 @@
6161561833 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6161661834 }
6161761835 // ACCUMULATE ARGUMENTS - END
61618- uint64_t return_to = 18446744073709547926LLU;
61836+ uint64_t return_to = 18446744073709547917LLU;
6161961837 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6162061838 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6162161839 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61624,14 +61842,14 @@
6162461842 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
6162561843 break;
6162661844 }
61627- case 18446744073709547926LLU: // 99999999FV'''''''''''''''
61845+ case 18446744073709547917LLU: // 99999999FM'''''''''''''''
6162861846 {
6162961847 // RELEASE temporary destructor-variable
6163061848 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
61631- state.addr = 18446744073709547927LLU; // 99999999FW'''''''''''''''
61849+ state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
6163261850 break;
6163361851 }
61634- case 18446744073709547928LLU: // 99999999FX'''''''''''''''
61852+ case 18446744073709547919LLU: // 99999999FO'''''''''''''''
6163561853 {
6163661854 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpresults at 17
6163761855 // parameter-reference u64 remainheap goes out of scope
@@ -61686,7 +61904,7 @@
6168661904 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6168761905 }
6168861906 // ACCUMULATE ARGUMENTS - END
61689- uint64_t return_to = 18446744073709547924LLU;
61907+ uint64_t return_to = 18446744073709547915LLU;
6169061908 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6169161909 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6169261910 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61695,12 +61913,12 @@
6169561913 state.addr = 839519719621918720LLU; // skipws____
6169661914 break;
6169761915 }
61698- case 18446744073709547924LLU: // 99999999FT'''''''''''''''
61916+ case 18446744073709547915LLU: // 99999999FK'''''''''''''''
6169961917 {
61700- state.addr = 18446744073709547925LLU; // 99999999FU'''''''''''''''
61918+ state.addr = 18446744073709547916LLU; // 99999999FL'''''''''''''''
6170161919 break;
6170261920 }
61703- case 18446744073709547925LLU: // 99999999FU'''''''''''''''
61921+ case 18446744073709547916LLU: // 99999999FL'''''''''''''''
6170461922 {
6170561923 /*id________*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 10LLU)));
6170661924 {
@@ -61719,10 +61937,10 @@
6171961937 };
6172061938 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6172161939 }
61722- state.addr = 18446744073709547923LLU; // 99999999FS'''''''''''''''
61940+ state.addr = 18446744073709547914LLU; // 99999999FJ'''''''''''''''
6172361941 break;
6172461942 }
61725- case 18446744073709547923LLU: // 99999999FS'''''''''''''''
61943+ case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
6172661944 {
6172761945 // ACCUMULATE ARGUMENTS - BEGIN
6172861946 {
@@ -61742,7 +61960,7 @@
6174261960 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6174361961 }
6174461962 // ACCUMULATE ARGUMENTS - END
61745- uint64_t return_to = 18446744073709547921LLU;
61963+ uint64_t return_to = 18446744073709547912LLU;
6174661964 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6174761965 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6174861966 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61751,12 +61969,12 @@
6175161969 state.addr = 782701543487916768LLU; // parsemtype
6175261970 break;
6175361971 }
61754- case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
61972+ case 18446744073709547912LLU: // 99999999FH'''''''''''''''
6175561973 {
61756- state.addr = 18446744073709547922LLU; // 99999999FR'''''''''''''''
61974+ state.addr = 18446744073709547913LLU; // 99999999FI'''''''''''''''
6175761975 break;
6175861976 }
61759- case 18446744073709547922LLU: // 99999999FR'''''''''''''''
61977+ case 18446744073709547913LLU: // 99999999FI'''''''''''''''
6176061978 {
6176161979 // ACCUMULATE ARGUMENTS - BEGIN
6176261980 {
@@ -61764,7 +61982,7 @@
6176461982 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6176561983 }
6176661984 // ACCUMULATE ARGUMENTS - END
61767- uint64_t return_to = 18446744073709547919LLU;
61985+ uint64_t return_to = 18446744073709547910LLU;
6176861986 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6176961987 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6177061988 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61773,12 +61991,12 @@
6177361991 state.addr = 839519719621918720LLU; // skipws____
6177461992 break;
6177561993 }
61776- case 18446744073709547919LLU: // 99999999FO'''''''''''''''
61994+ case 18446744073709547910LLU: // 99999999FF'''''''''''''''
6177761995 {
61778- state.addr = 18446744073709547920LLU; // 99999999FP'''''''''''''''
61996+ state.addr = 18446744073709547911LLU; // 99999999FG'''''''''''''''
6177961997 break;
6178061998 }
61781- case 18446744073709547920LLU: // 99999999FP'''''''''''''''
61999+ case 18446744073709547911LLU: // 99999999FG'''''''''''''''
6178262000 {
6178362001 /*id________*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 10LLU)));
6178462002 {
@@ -61803,7 +62021,7 @@
6180362021 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6180462022 }
6180562023 // ACCUMULATE ARGUMENTS - END
61806- uint64_t return_to = 18446744073709547917LLU;
62024+ uint64_t return_to = 18446744073709547908LLU;
6180762025 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6180862026 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6180962027 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61812,17 +62030,17 @@
6181262030 state.addr = 696275824427849761LLU; // knowvarref
6181362031 break;
6181462032 }
61815- case 18446744073709547917LLU: // 99999999FM'''''''''''''''
62033+ case 18446744073709547908LLU: // 99999999FD'''''''''''''''
6181662034 {
61817- state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
62035+ state.addr = 18446744073709547909LLU; // 99999999FE'''''''''''''''
6181862036 break;
6181962037 }
61820- case 18446744073709547918LLU: // 99999999FN'''''''''''''''
62038+ case 18446744073709547909LLU: // 99999999FE'''''''''''''''
6182162039 {
61822- state.addr = /*redef_____*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709547916LLU : 18446744073709547915LLU;
62040+ state.addr = /*redef_____*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709547907LLU : 18446744073709547906LLU;
6182362041 break;
6182462042 }
61825- case 18446744073709547916LLU: // 99999999FL'''''''''''''''
62043+ case 18446744073709547907LLU: // 99999999FC'''''''''''''''
6182662044 {
6182762045 {
6182862046 uint64_t arg = 0LLU;
@@ -61834,7 +62052,7 @@
6183462052 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6183562053 }
6183662054 // ACCUMULATE ARGUMENTS - END
61837- uint64_t return_to = 18446744073709547913LLU;
62055+ uint64_t return_to = 18446744073709547904LLU;
6183862056 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6183962057 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6184062058 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61843,12 +62061,12 @@
6184362061 state.addr = 839519719621918720LLU; // skipws____
6184462062 break;
6184562063 }
61846- case 18446744073709547913LLU: // 99999999FI'''''''''''''''
62064+ case 18446744073709547904LLU: // 99999999F_'''''''''''''''
6184762065 {
61848- state.addr = 18446744073709547914LLU; // 99999999FJ'''''''''''''''
62066+ state.addr = 18446744073709547905LLU; // 99999999FA'''''''''''''''
6184962067 break;
6185062068 }
61851- case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
62069+ case 18446744073709547905LLU: // 99999999FA'''''''''''''''
6185262070 {
6185362071 /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
6185462072 {
@@ -61856,17 +62074,17 @@
6185662074 LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6185762075 }
6185862076 /*shadow____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*buf_______*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /*shadow____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU);
61859- state.addr = /*shadow____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547912LLU : 18446744073709547911LLU;
62077+ state.addr = /*shadow____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547903LLU : 18446744073709547902LLU;
6186062078 break;
6186162079 }
61862- case 18446744073709547912LLU: // 99999999FH'''''''''''''''
62080+ case 18446744073709547903LLU: // 99999999E9'''''''''''''''
6186362081 {
6186462082 heap.availilable_size_for_dynamic_objects += 0LLU;
6186562083 heap.availilable_size_for_dynamic_objects += 0LLU;
61866- state.addr = 18446744073709547910LLU; // 99999999FF'''''''''''''''
62084+ state.addr = 18446744073709547901LLU; // 99999999E7'''''''''''''''
6186762085 break;
6186862086 }
61869- case 18446744073709547911LLU: // 99999999FG'''''''''''''''
62087+ case 18446744073709547902LLU: // 99999999E8'''''''''''''''
6187062088 {
6187162089 // ACCUMULATE ARGUMENTS - BEGIN
6187262090 {
@@ -61874,7 +62092,7 @@
6187462092 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6187562093 }
6187662094 // ACCUMULATE ARGUMENTS - END
61877- uint64_t return_to = 18446744073709547908LLU;
62095+ uint64_t return_to = 18446744073709547899LLU;
6187862096 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6187962097 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6188062098 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61883,12 +62101,12 @@
6188362101 state.addr = 819847183515949359LLU; // reportinit
6188462102 break;
6188562103 }
61886- case 18446744073709547908LLU: // 99999999FD'''''''''''''''
62104+ case 18446744073709547899LLU: // 99999999E5'''''''''''''''
6188762105 {
61888- state.addr = 18446744073709547909LLU; // 99999999FE'''''''''''''''
62106+ state.addr = 18446744073709547900LLU; // 99999999E6'''''''''''''''
6188962107 break;
6189062108 }
61891- case 18446744073709547909LLU: // 99999999FE'''''''''''''''
62109+ case 18446744073709547900LLU: // 99999999E6'''''''''''''''
6189262110 {
6189362111 fprintf(stderr, "%s", "variable ");
6189462112 printid(stderr, /*id________*/*LOCAL_ACCESS(heap.data, 21LLU, 15LLU));
@@ -61898,10 +62116,10 @@
6189862116 fprintf(stderr, "%s\n", "");
6189962117 exit(-1);
6190062118 }
61901- state.addr = 18446744073709547910LLU; // 99999999FF'''''''''''''''
62119+ state.addr = 18446744073709547901LLU; // 99999999E7'''''''''''''''
6190262120 break;
6190362121 }
61904- case 18446744073709547910LLU: // 99999999FF'''''''''''''''
62122+ case 18446744073709547901LLU: // 99999999E7'''''''''''''''
6190562123 {
6190662124 // variable u64 shadow____ goes out of scope
6190762125 // emitted destructur for type u64
@@ -61909,10 +62127,10 @@
6190962127 // variable u64 buf_______ goes out of scope
6191062128 // emitted destructur for type u64
6191162129 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference buf_______ at 20
61912- state.addr = 18446744073709547915LLU; // 99999999FK'''''''''''''''
62130+ state.addr = 18446744073709547906LLU; // 99999999FB'''''''''''''''
6191362131 break;
6191462132 }
61915- case 18446744073709547915LLU: // 99999999FK'''''''''''''''
62133+ case 18446744073709547906LLU: // 99999999FB'''''''''''''''
6191662134 {
6191762135 // ACCUMULATE ARGUMENTS - BEGIN
6191862136 {
@@ -61936,7 +62154,7 @@
6193662154 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6193762155 }
6193862156 // ACCUMULATE ARGUMENTS - END
61939- uint64_t return_to = 18446744073709547906LLU;
62157+ uint64_t return_to = 18446744073709547897LLU;
6194062158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6194162159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6194262160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61945,12 +62163,12 @@
6194562163 state.addr = 515555125197130432LLU; // allocheap_
6194662164 break;
6194762165 }
61948- case 18446744073709547906LLU: // 99999999FB'''''''''''''''
62166+ case 18446744073709547897LLU: // 99999999E3'''''''''''''''
6194962167 {
61950- state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
62168+ state.addr = 18446744073709547898LLU; // 99999999E4'''''''''''''''
6195162169 break;
6195262170 }
61953- case 18446744073709547907LLU: // 99999999FC'''''''''''''''
62171+ case 18446744073709547898LLU: // 99999999E4'''''''''''''''
6195462172 {
6195562173 // ACCUMULATE ARGUMENTS - BEGIN
6195662174 {
@@ -61958,7 +62176,7 @@
6195862176 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6195962177 }
6196062178 // ACCUMULATE ARGUMENTS - END
61961- uint64_t return_to = 18446744073709547903LLU;
62179+ uint64_t return_to = 18446744073709547894LLU;
6196262180 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6196362181 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6196462182 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61967,12 +62185,12 @@
6196762185 state.addr = 839519719621918720LLU; // skipws____
6196862186 break;
6196962187 }
61970- case 18446744073709547903LLU: // 99999999E9'''''''''''''''
62188+ case 18446744073709547894LLU: // 99999999E0'''''''''''''''
6197162189 {
61972- state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
62190+ state.addr = 18446744073709547895LLU; // 99999999E1'''''''''''''''
6197362191 break;
6197462192 }
61975- case 18446744073709547904LLU: // 99999999F_'''''''''''''''
62193+ case 18446744073709547895LLU: // 99999999E1'''''''''''''''
6197662194 {
6197762195 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
6197862196 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61981,7 +62199,7 @@
6198162199 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6198262200 }
6198362201 // ACCUMULATE ARGUMENTS - END
61984- uint64_t return_to = 18446744073709547901LLU;
62202+ uint64_t return_to = 18446744073709547892LLU;
6198562203 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6198662204 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6198762205 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61990,12 +62208,12 @@
6199062208 state.addr = 839519719621918720LLU; // skipws____
6199162209 break;
6199262210 }
61993- case 18446744073709547901LLU: // 99999999E7'''''''''''''''
62211+ case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
6199462212 {
61995- state.addr = 18446744073709547902LLU; // 99999999E8'''''''''''''''
62213+ state.addr = 18446744073709547893LLU; // 99999999Ez'''''''''''''''
6199662214 break;
6199762215 }
61998- case 18446744073709547902LLU: // 99999999E8'''''''''''''''
62216+ case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
6199962217 {
6200062218 {
6200162219 uint64_t arg = 0LLU;
@@ -62004,10 +62222,10 @@
6200462222 *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 59LLU;
6200562223
6200662224 /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU));
62007- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547900LLU : 18446744073709547899LLU;
62225+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547891LLU : 18446744073709547890LLU;
6200862226 break;
6200962227 }
62010- case 18446744073709547900LLU: // 99999999E6'''''''''''''''
62228+ case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
6201162229 {
6201262230 matchid(";", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
6201362231 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62020,7 +62238,7 @@
6202062238 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6202162239 }
6202262240 // ACCUMULATE ARGUMENTS - END
62023- uint64_t return_to = 18446744073709547897LLU;
62241+ uint64_t return_to = 18446744073709547888LLU;
6202462242 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6202562243 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6202662244 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62029,12 +62247,12 @@
6202962247 state.addr = 517555565476695680LLU; // assertu64_
6203062248 break;
6203162249 }
62032- case 18446744073709547897LLU: // 99999999E3'''''''''''''''
62250+ case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
6203362251 {
62034- state.addr = 18446744073709547898LLU; // 99999999E4'''''''''''''''
62252+ state.addr = 18446744073709547889LLU; // 99999999Ev'''''''''''''''
6203562253 break;
6203662254 }
62037- case 18446744073709547898LLU: // 99999999E4'''''''''''''''
62255+ case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
6203862256 {
6203962257 {
6204062258 uint64_t arg = 0LLU;
@@ -62042,7 +62260,7 @@
6204262260 }
6204362261 // ACCUMULATE ARGUMENTS - BEGIN
6204462262 // ACCUMULATE ARGUMENTS - END
62045- uint64_t return_to = 18446744073709547895LLU;
62263+ uint64_t return_to = 18446744073709547886LLU;
6204662264 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
6204762265 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6204862266 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62051,12 +62269,12 @@
6205162269 state.addr = 890787671342055424LLU; // varopen___
6205262270 break;
6205362271 }
62054- case 18446744073709547895LLU: // 99999999E1'''''''''''''''
62272+ case 18446744073709547886LLU: // 99999999Es'''''''''''''''
6205562273 {
62056- state.addr = 18446744073709547896LLU; // 99999999E2'''''''''''''''
62274+ state.addr = 18446744073709547887LLU; // 99999999Et'''''''''''''''
6205762275 break;
6205862276 }
62059- case 18446744073709547896LLU: // 99999999E2'''''''''''''''
62277+ case 18446744073709547887LLU: // 99999999Et'''''''''''''''
6206062278 {
6206162279 fprintf(stdout, "%s", "0");
6206262280 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62081,7 +62299,7 @@
6208162299 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6208262300 }
6208362301 // ACCUMULATE ARGUMENTS - END
62084- uint64_t return_to = 18446744073709547893LLU;
62302+ uint64_t return_to = 18446744073709547884LLU;
6208562303 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6208662304 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6208762305 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62090,12 +62308,12 @@
6209062308 state.addr = 890786842582581248LLU; // varclose__
6209162309 break;
6209262310 }
62093- case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
62311+ case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
6209462312 {
62095- state.addr = 18446744073709547894LLU; // 99999999E0'''''''''''''''
62313+ state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
6209662314 break;
6209762315 }
62098- case 18446744073709547894LLU: // 99999999E0'''''''''''''''
62316+ case 18446744073709547885LLU: // 99999999Er'''''''''''''''
6209962317 {
6210062318 {
6210162319 uint64_t arg = 0LLU;
@@ -62119,7 +62337,7 @@
6211962337 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6212062338 }
6212162339 // ACCUMULATE ARGUMENTS - END
62122- uint64_t return_to = 18446744073709547890LLU;
62340+ uint64_t return_to = 18446744073709547881LLU;
6212362341 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6212462342 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6212562343 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62128,12 +62346,12 @@
6212862346 state.addr = 367395560426147840LLU; // TYPECOPY__
6212962347 break;
6213062348 }
62131- case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
62349+ case 18446744073709547881LLU: // 99999999En'''''''''''''''
6213262350 {
62133- state.addr = 18446744073709547891LLU; // 99999999Ex'''''''''''''''
62351+ state.addr = 18446744073709547882LLU; // 99999999Eo'''''''''''''''
6213462352 break;
6213562353 }
62136- case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
62354+ case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
6213762355 {
6213862356 // ACCUMULATE ARGUMENTS - BEGIN
6213962357 {
@@ -62165,7 +62383,7 @@
6216562383 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6216662384 }
6216762385 // ACCUMULATE ARGUMENTS - END
62168- uint64_t return_to = 18446744073709547888LLU;
62386+ uint64_t return_to = 18446744073709547879LLU;
6216962387 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6217062388 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6217162389 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62174,12 +62392,12 @@
6217462392 state.addr = 788334703205941248LLU; // pushvar___
6217562393 break;
6217662394 }
62177- case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
62395+ case 18446744073709547879LLU: // 99999999El'''''''''''''''
6217862396 {
62179- state.addr = 18446744073709547889LLU; // 99999999Ev'''''''''''''''
62397+ state.addr = 18446744073709547880LLU; // 99999999Em'''''''''''''''
6218062398 break;
6218162399 }
62182- case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
62400+ case 18446744073709547880LLU: // 99999999Em'''''''''''''''
6218362401 {
6218462402 // variable type______ t_________ goes out of scope
6218562403 // emitted destructur for type type______
@@ -62189,7 +62407,7 @@
6218962407 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6219062408 }
6219162409 // ACCUMULATE ARGUMENTS - END
62192- uint64_t return_to = 18446744073709547887LLU;
62410+ uint64_t return_to = 18446744073709547878LLU;
6219362411 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6219462412 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6219562413 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62198,7 +62416,7 @@
6219862416 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6219962417 break;
6220062418 }
62201- case 18446744073709547887LLU: // 99999999Et'''''''''''''''
62419+ case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
6220262420 {
6220362421 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 24
6220462422 // variable u64 initialize goes out of scope
@@ -62207,10 +62425,10 @@
6220762425 // variable u64 INDIRECT__ goes out of scope
6220862426 // emitted destructur for type u64
6220962427 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 22
62210- state.addr = 18446744073709547892LLU; // 99999999Ey'''''''''''''''
62428+ state.addr = 18446744073709547883LLU; // 99999999Ep'''''''''''''''
6221162429 break;
6221262430 }
62213- case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
62431+ case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
6221462432 {
6221562433 // variable u64 varidx____ goes out of scope
6221662434 // emitted destructur for type u64
@@ -62217,10 +62435,10 @@
6221762435 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 21
6221862436 heap.availilable_size_for_dynamic_objects += 0LLU;
6221962437 heap.availilable_size_for_dynamic_objects += 0LLU;
62220- state.addr = 18446744073709547886LLU; // 99999999Es'''''''''''''''
62438+ state.addr = 18446744073709547877LLU; // 99999999Ej'''''''''''''''
6222162439 break;
6222262440 }
62223- case 18446744073709547899LLU: // 99999999E5'''''''''''''''
62441+ case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
6222462442 {
6222562443 // ACCUMULATE ARGUMENTS - BEGIN
6222662444 {
@@ -62228,7 +62446,7 @@
6222862446 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6222962447 }
6223062448 // ACCUMULATE ARGUMENTS - END
62231- uint64_t return_to = 18446744073709547884LLU;
62449+ uint64_t return_to = 18446744073709547875LLU;
6223262450 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6223362451 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6223462452 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62237,12 +62455,12 @@
6223762455 state.addr = 839519719621918720LLU; // skipws____
6223862456 break;
6223962457 }
62240- case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
62458+ case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
6224162459 {
62242- state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
62460+ state.addr = 18446744073709547876LLU; // 99999999Ei'''''''''''''''
6224362461 break;
6224462462 }
62245- case 18446744073709547885LLU: // 99999999Er'''''''''''''''
62463+ case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
6224662464 {
6224762465 // ACCUMULATE ARGUMENTS - BEGIN
6224862466 {
@@ -62254,7 +62472,7 @@
6225462472 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6225562473 }
6225662474 // ACCUMULATE ARGUMENTS - END
62257- uint64_t return_to = 18446744073709547882LLU;
62475+ uint64_t return_to = 18446744073709547873LLU;
6225862476 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6225962477 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6226062478 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62263,21 +62481,21 @@
6226362481 state.addr = 661605045736570880LLU; // isdigit___
6226462482 break;
6226562483 }
62266- case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
62484+ case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
6226762485 {
62268- state.addr = 18446744073709547883LLU; // 99999999Ep'''''''''''''''
62486+ state.addr = 18446744073709547874LLU; // 99999999Eg'''''''''''''''
6226962487 break;
6227062488 }
62271- case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
62489+ case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
6227262490 {
62273- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547881LLU : 18446744073709547880LLU;
62491+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547872LLU : 18446744073709547871LLU;
6227462492 break;
6227562493 }
62276- case 18446744073709547881LLU: // 99999999En'''''''''''''''
62494+ case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
6227762495 {
6227862496 // ACCUMULATE ARGUMENTS - BEGIN
6227962497 // ACCUMULATE ARGUMENTS - END
62280- uint64_t return_to = 18446744073709547878LLU;
62498+ uint64_t return_to = 18446744073709547869LLU;
6228162499 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
6228262500 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6228362501 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62286,12 +62504,12 @@
6228662504 state.addr = 890787671342055424LLU; // varopen___
6228762505 break;
6228862506 }
62289- case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
62507+ case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
6229062508 {
62291- state.addr = 18446744073709547879LLU; // 99999999El'''''''''''''''
62509+ state.addr = 18446744073709547870LLU; // 99999999Ec'''''''''''''''
6229262510 break;
6229362511 }
62294- case 18446744073709547879LLU: // 99999999El'''''''''''''''
62512+ case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
6229562513 {
6229662514 /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
6229762515 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62300,7 +62518,7 @@
6230062518 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6230162519 }
6230262520 // ACCUMULATE ARGUMENTS - END
62303- uint64_t return_to = 18446744073709547876LLU;
62521+ uint64_t return_to = 18446744073709547867LLU;
6230462522 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6230562523 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6230662524 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62309,17 +62527,17 @@
6230962527 state.addr = 787446708198178816LLU; // printnr___
6231062528 break;
6231162529 }
62312- case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
62530+ case 18446744073709547867LLU: // 99999999E$'''''''''''''''
6231362531 {
62314- state.addr = 18446744073709547877LLU; // 99999999Ej'''''''''''''''
62532+ state.addr = 18446744073709547868LLU; // 99999999Ea'''''''''''''''
6231562533 break;
6231662534 }
62317- case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
62535+ case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
6231862536 {
62319- state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547875LLU : 18446744073709547874LLU;
62537+ state.addr = /*buf_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547866LLU : 18446744073709547865LLU;
6232062538 break;
6232162539 }
62322- case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
62540+ case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
6232362541 {
6232462542 // ACCUMULATE ARGUMENTS - BEGIN
6232562543 {
@@ -62331,7 +62549,7 @@
6233162549 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6233262550 }
6233362551 // ACCUMULATE ARGUMENTS - END
62334- uint64_t return_to = 18446744073709547872LLU;
62552+ uint64_t return_to = 18446744073709547863LLU;
6233562553 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6233662554 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6233762555 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62340,17 +62558,17 @@
6234062558 state.addr = 517555565476695680LLU; // assertu64_
6234162559 break;
6234262560 }
62343- case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
62561+ case 18446744073709547863LLU: // 99999999EW'''''''''''''''
6234462562 {
62345- state.addr = 18446744073709547873LLU; // 99999999Ef'''''''''''''''
62563+ state.addr = 18446744073709547864LLU; // 99999999EX'''''''''''''''
6234662564 break;
6234762565 }
62348- case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
62566+ case 18446744073709547864LLU: // 99999999EX'''''''''''''''
6234962567 {
62350- state.addr = 18446744073709547874LLU; // 99999999Eg'''''''''''''''
62568+ state.addr = 18446744073709547865LLU; // 99999999EY'''''''''''''''
6235162569 break;
6235262570 }
62353- case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
62571+ case 18446744073709547865LLU: // 99999999EY'''''''''''''''
6235462572 {
6235562573 {
6235662574 uint64_t arg = 0LLU;
@@ -62378,7 +62596,7 @@
6237862596 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6237962597 }
6238062598 // ACCUMULATE ARGUMENTS - END
62381- uint64_t return_to = 18446744073709547870LLU;
62599+ uint64_t return_to = 18446744073709547861LLU;
6238262600 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6238362601 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6238462602 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62387,12 +62605,12 @@
6238762605 state.addr = 890786842582581248LLU; // varclose__
6238862606 break;
6238962607 }
62390- case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
62608+ case 18446744073709547861LLU: // 99999999EU'''''''''''''''
6239162609 {
62392- state.addr = 18446744073709547871LLU; // 99999999Ed'''''''''''''''
62610+ state.addr = 18446744073709547862LLU; // 99999999EV'''''''''''''''
6239362611 break;
6239462612 }
62395- case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
62613+ case 18446744073709547862LLU: // 99999999EV'''''''''''''''
6239662614 {
6239762615 {
6239862616 uint64_t arg = 0LLU;
@@ -62412,7 +62630,7 @@
6241262630 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6241362631 }
6241462632 // ACCUMULATE ARGUMENTS - END
62415- uint64_t return_to = 18446744073709547867LLU;
62633+ uint64_t return_to = 18446744073709547858LLU;
6241662634 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6241762635 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6241862636 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62421,12 +62639,12 @@
6242162639 state.addr = 661658442972266496LLU; // isprim____
6242262640 break;
6242362641 }
62424- case 18446744073709547867LLU: // 99999999E$'''''''''''''''
62642+ case 18446744073709547858LLU: // 99999999ER'''''''''''''''
6242562643 {
62426- state.addr = 18446744073709547868LLU; // 99999999Ea'''''''''''''''
62644+ state.addr = 18446744073709547859LLU; // 99999999ES'''''''''''''''
6242762645 break;
6242862646 }
62429- case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
62647+ case 18446744073709547859LLU: // 99999999ES'''''''''''''''
6243062648 {
6243162649 {
6243262650 uint64_t arg = 0LLU;
@@ -62442,7 +62660,7 @@
6244262660 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6244362661 }
6244462662 // ACCUMULATE ARGUMENTS - END
62445- uint64_t return_to = 18446744073709547865LLU;
62663+ uint64_t return_to = 18446744073709547856LLU;
6244662664 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6244762665 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6244862666 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62451,12 +62669,12 @@
6245162669 state.addr = 367395560426147840LLU; // TYPECOPY__
6245262670 break;
6245362671 }
62454- case 18446744073709547865LLU: // 99999999EY'''''''''''''''
62672+ case 18446744073709547856LLU: // 99999999EP'''''''''''''''
6245562673 {
62456- state.addr = 18446744073709547866LLU; // 99999999EZ'''''''''''''''
62674+ state.addr = 18446744073709547857LLU; // 99999999EQ'''''''''''''''
6245762675 break;
6245862676 }
62459- case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
62677+ case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
6246062678 {
6246162679 // ACCUMULATE ARGUMENTS - BEGIN
6246262680 {
@@ -62488,7 +62706,7 @@
6248862706 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6248962707 }
6249062708 // ACCUMULATE ARGUMENTS - END
62491- uint64_t return_to = 18446744073709547863LLU;
62709+ uint64_t return_to = 18446744073709547854LLU;
6249262710 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6249362711 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6249462712 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62497,12 +62715,12 @@
6249762715 state.addr = 788334703205941248LLU; // pushvar___
6249862716 break;
6249962717 }
62500- case 18446744073709547863LLU: // 99999999EW'''''''''''''''
62718+ case 18446744073709547854LLU: // 99999999EN'''''''''''''''
6250162719 {
62502- state.addr = 18446744073709547864LLU; // 99999999EX'''''''''''''''
62720+ state.addr = 18446744073709547855LLU; // 99999999EO'''''''''''''''
6250362721 break;
6250462722 }
62505- case 18446744073709547864LLU: // 99999999EX'''''''''''''''
62723+ case 18446744073709547855LLU: // 99999999EO'''''''''''''''
6250662724 {
6250762725 // variable type______ t_________ goes out of scope
6250862726 // emitted destructur for type type______
@@ -62512,7 +62730,7 @@
6251262730 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6251362731 }
6251462732 // ACCUMULATE ARGUMENTS - END
62515- uint64_t return_to = 18446744073709547862LLU;
62733+ uint64_t return_to = 18446744073709547853LLU;
6251662734 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6251762735 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6251862736 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62521,7 +62739,7 @@
6252162739 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6252262740 break;
6252362741 }
62524- case 18446744073709547862LLU: // 99999999EV'''''''''''''''
62742+ case 18446744073709547853LLU: // 99999999EM'''''''''''''''
6252562743 {
6252662744 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 24
6252762745 // variable u64 initialize goes out of scope
@@ -62530,10 +62748,10 @@
6253062748 // variable u64 INDIRECT__ goes out of scope
6253162749 // emitted destructur for type u64
6253262750 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 22
62533- state.addr = 18446744073709547869LLU; // 99999999Eb'''''''''''''''
62751+ state.addr = 18446744073709547860LLU; // 99999999ET'''''''''''''''
6253462752 break;
6253562753 }
62536- case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
62754+ case 18446744073709547860LLU: // 99999999ET'''''''''''''''
6253762755 {
6253862756 // variable u64 varidx____ goes out of scope
6253962757 // emitted destructur for type u64
@@ -62540,10 +62758,10 @@
6254062758 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 21
6254162759 heap.availilable_size_for_dynamic_objects += 0LLU;
6254262760 heap.availilable_size_for_dynamic_objects += 0LLU;
62543- state.addr = 18446744073709547861LLU; // 99999999EU'''''''''''''''
62761+ state.addr = 18446744073709547852LLU; // 99999999EL'''''''''''''''
6254462762 break;
6254562763 }
62546- case 18446744073709547880LLU: // 99999999Em'''''''''''''''
62764+ case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
6254762765 {
6254862766 {
6254962767 uint64_t arg = 0LLU;
@@ -62559,7 +62777,7 @@
6255962777 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6256062778 }
6256162779 // ACCUMULATE ARGUMENTS - END
62562- uint64_t return_to = 18446744073709547859LLU;
62780+ uint64_t return_to = 18446744073709547850LLU;
6256362781 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6256462782 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6256562783 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62568,12 +62786,12 @@
6256862786 state.addr = 839519719621918720LLU; // skipws____
6256962787 break;
6257062788 }
62571- case 18446744073709547859LLU: // 99999999ES'''''''''''''''
62789+ case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
6257262790 {
62573- state.addr = 18446744073709547860LLU; // 99999999ET'''''''''''''''
62791+ state.addr = 18446744073709547851LLU; // 99999999EK'''''''''''''''
6257462792 break;
6257562793 }
62576- case 18446744073709547860LLU: // 99999999ET'''''''''''''''
62794+ case 18446744073709547851LLU: // 99999999EK'''''''''''''''
6257762795 {
6257862796 /*argid_____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 10LLU)));
6257962797 {
@@ -62602,7 +62820,7 @@
6260262820 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6260362821 }
6260462822 // ACCUMULATE ARGUMENTS - END
62605- uint64_t return_to = 18446744073709547857LLU;
62823+ uint64_t return_to = 18446744073709547848LLU;
6260662824 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6260762825 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6260862826 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62611,17 +62829,17 @@
6261162829 state.addr = 750629765416882176LLU; // novarref__
6261262830 break;
6261362831 }
62614- case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
62832+ case 18446744073709547848LLU: // 99999999EH'''''''''''''''
6261562833 {
62616- state.addr = 18446744073709547858LLU; // 99999999ER'''''''''''''''
62834+ state.addr = 18446744073709547849LLU; // 99999999EI'''''''''''''''
6261762835 break;
6261862836 }
62619- case 18446744073709547858LLU: // 99999999ER'''''''''''''''
62837+ case 18446744073709547849LLU: // 99999999EI'''''''''''''''
6262062838 {
62621- state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547856LLU : 18446744073709547855LLU;
62839+ state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547847LLU : 18446744073709547846LLU;
6262262840 break;
6262362841 }
62624- case 18446744073709547856LLU: // 99999999EP'''''''''''''''
62842+ case 18446744073709547847LLU: // 99999999EG'''''''''''''''
6262562843 {
6262662844 {
6262762845 uint64_t arg = 0LLU;
@@ -62633,7 +62851,7 @@
6263362851 }
6263462852 // ACCUMULATE ARGUMENTS - BEGIN
6263562853 // ACCUMULATE ARGUMENTS - END
62636- uint64_t return_to = 18446744073709547851LLU;
62854+ uint64_t return_to = 18446744073709547842LLU;
6263762855 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
6263862856 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6263962857 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62642,12 +62860,12 @@
6264262860 state.addr = 890787671342055424LLU; // varopen___
6264362861 break;
6264462862 }
62645- case 18446744073709547851LLU: // 99999999EK'''''''''''''''
62863+ case 18446744073709547842LLU: // 99999999EB'''''''''''''''
6264662864 {
62647- state.addr = 18446744073709547852LLU; // 99999999EL'''''''''''''''
62865+ state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
6264862866 break;
6264962867 }
62650- case 18446744073709547852LLU: // 99999999EL'''''''''''''''
62868+ case 18446744073709547843LLU: // 99999999EC'''''''''''''''
6265162869 {
6265262870 fprintf(stdout, "%s", "0");
6265362871 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62672,7 +62890,7 @@
6267262890 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6267362891 }
6267462892 // ACCUMULATE ARGUMENTS - END
62675- uint64_t return_to = 18446744073709547849LLU;
62893+ uint64_t return_to = 18446744073709547840LLU;
6267662894 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6267762895 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6267862896 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62681,12 +62899,12 @@
6268162899 state.addr = 890786842582581248LLU; // varclose__
6268262900 break;
6268362901 }
62684- case 18446744073709547849LLU: // 99999999EI'''''''''''''''
62902+ case 18446744073709547840LLU: // 99999999E_'''''''''''''''
6268562903 {
62686- state.addr = 18446744073709547850LLU; // 99999999EJ'''''''''''''''
62904+ state.addr = 18446744073709547841LLU; // 99999999EA'''''''''''''''
6268762905 break;
6268862906 }
62689- case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
62907+ case 18446744073709547841LLU: // 99999999EA'''''''''''''''
6269062908 {
6269162909 {
6269262910 uint64_t arg = 0LLU;
@@ -62710,7 +62928,7 @@
6271062928 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6271162929 }
6271262930 // ACCUMULATE ARGUMENTS - END
62713- uint64_t return_to = 18446744073709547847LLU;
62931+ uint64_t return_to = 18446744073709547838LLU;
6271462932 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6271562933 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6271662934 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62719,12 +62937,12 @@
6271962937 state.addr = 768289076452424640LLU; // oneresult_
6272062938 break;
6272162939 }
62722- case 18446744073709547847LLU: // 99999999EG'''''''''''''''
62940+ case 18446744073709547838LLU: // 99999999D8'''''''''''''''
6272362941 {
62724- state.addr = 18446744073709547848LLU; // 99999999EH'''''''''''''''
62942+ state.addr = 18446744073709547839LLU; // 99999999D9'''''''''''''''
6272562943 break;
6272662944 }
62727- case 18446744073709547848LLU: // 99999999EH'''''''''''''''
62945+ case 18446744073709547839LLU: // 99999999D9'''''''''''''''
6272862946 {
6272962947 // ACCUMULATE ARGUMENTS - BEGIN
6273062948 {
@@ -62796,7 +63014,7 @@
6279663014 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6279763015 }
6279863016 // ACCUMULATE ARGUMENTS - END
62799- uint64_t return_to = 18446744073709547845LLU;
63017+ uint64_t return_to = 18446744073709547836LLU;
6280063018 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6280163019 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6280263020 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62805,23 +63023,23 @@
6280563023 state.addr = 782701543315110336LLU; // parsecall_
6280663024 break;
6280763025 }
62808- case 18446744073709547845LLU: // 99999999EE'''''''''''''''
63026+ case 18446744073709547836LLU: // 99999999D6'''''''''''''''
6280963027 {
62810- state.addr = 18446744073709547846LLU; // 99999999EF'''''''''''''''
63028+ state.addr = 18446744073709547837LLU; // 99999999D7'''''''''''''''
6281163029 break;
6281263030 }
62813- case 18446744073709547846LLU: // 99999999EF'''''''''''''''
63031+ case 18446744073709547837LLU: // 99999999D7'''''''''''''''
6281463032 {
6281563033 // variable list<resdest___> newresults goes out of scope
6281663034 // emitted destructur for type list<resdest___>
62817- state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
63035+ state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
6281863036 break;
6281963037 }
62820- case 18446744073709547843LLU: // 99999999EC'''''''''''''''
63038+ case 18446744073709547834LLU: // 99999999D4'''''''''''''''
6282163039 {
6282263040 if(!*LOCAL_ACCESS(heap.data, 26LLU, 25LLU)/*list*/)
6282363041 {
62824- state.addr = 18446744073709547844LLU; // 99999999ED'''''''''''''''
63042+ state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
6282563043 break;
6282663044 }
6282763045 // temporary list-element
@@ -62835,7 +63053,7 @@
6283563053 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6283663054 }
6283763055 // ACCUMULATE ARGUMENTS - END
62838- uint64_t return_to = 18446744073709547842LLU;
63056+ uint64_t return_to = 18446744073709547833LLU;
6283963057 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6284063058 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6284163059 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62844,20 +63062,20 @@
6284463062 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
6284563063 break;
6284663064 }
62847- case 18446744073709547842LLU: // 99999999EB'''''''''''''''
63065+ case 18446744073709547833LLU: // 99999999D3'''''''''''''''
6284863066 {
6284963067 // RELEASE temporary destructor-variable
6285063068 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 27
62851- state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
63069+ state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
6285263070 break;
6285363071 }
62854- case 18446744073709547844LLU: // 99999999ED'''''''''''''''
63072+ case 18446744073709547835LLU: // 99999999D5'''''''''''''''
6285563073 {
6285663074 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 26
62857- state.addr = 18446744073709547853LLU; // 99999999EM'''''''''''''''
63075+ state.addr = 18446744073709547844LLU; // 99999999ED'''''''''''''''
6285863076 break;
6285963077 }
62860- case 18446744073709547853LLU: // 99999999EM'''''''''''''''
63078+ case 18446744073709547844LLU: // 99999999ED'''''''''''''''
6286163079 {
6286263080 {
6286363081 uint64_t arg = 1LLU;
@@ -62893,7 +63111,7 @@
6289363111 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6289463112 }
6289563113 // ACCUMULATE ARGUMENTS - END
62896- uint64_t return_to = 18446744073709547840LLU;
63114+ uint64_t return_to = 18446744073709547831LLU;
6289763115 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6289863116 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6289963117 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62902,12 +63120,12 @@
6290263120 state.addr = 788334703205941248LLU; // pushvar___
6290363121 break;
6290463122 }
62905- case 18446744073709547840LLU: // 99999999E_'''''''''''''''
63123+ case 18446744073709547831LLU: // 99999999D1'''''''''''''''
6290663124 {
62907- state.addr = 18446744073709547841LLU; // 99999999EA'''''''''''''''
63125+ state.addr = 18446744073709547832LLU; // 99999999D2'''''''''''''''
6290863126 break;
6290963127 }
62910- case 18446744073709547841LLU: // 99999999EA'''''''''''''''
63128+ case 18446744073709547832LLU: // 99999999D2'''''''''''''''
6291163129 {
6291263130 // variable u64 initialize goes out of scope
6291363131 // emitted destructur for type u64
@@ -62918,17 +63136,17 @@
6291863136 // variable u64 varidx____ goes out of scope
6291963137 // emitted destructur for type u64
6292063138 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 24
62921- state.addr = 18446744073709547854LLU; // 99999999EN'''''''''''''''
63139+ state.addr = 18446744073709547845LLU; // 99999999EE'''''''''''''''
6292263140 break;
6292363141 }
62924- case 18446744073709547854LLU: // 99999999EN'''''''''''''''
63142+ case 18446744073709547845LLU: // 99999999EE'''''''''''''''
6292563143 {
6292663144 heap.availilable_size_for_dynamic_objects += 0LLU;
6292763145 heap.availilable_size_for_dynamic_objects += 0LLU;
62928- state.addr = 18446744073709547839LLU; // 99999999D9'''''''''''''''
63146+ state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
6292963147 break;
6293063148 }
62931- case 18446744073709547855LLU: // 99999999EO'''''''''''''''
63149+ case 18446744073709547846LLU: // 99999999EF'''''''''''''''
6293263150 {
6293363151 {
6293463152 uint64_t arg = 0LLU;
@@ -62936,7 +63154,7 @@
6293663154 }
6293763155 // ACCUMULATE ARGUMENTS - BEGIN
6293863156 // ACCUMULATE ARGUMENTS - END
62939- uint64_t return_to = 18446744073709547837LLU;
63157+ uint64_t return_to = 18446744073709547828LLU;
6294063158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
6294163159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6294263160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62945,12 +63163,12 @@
6294563163 state.addr = 890787671342055424LLU; // varopen___
6294663164 break;
6294763165 }
62948- case 18446744073709547837LLU: // 99999999D7'''''''''''''''
63166+ case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
6294963167 {
62950- state.addr = 18446744073709547838LLU; // 99999999D8'''''''''''''''
63168+ state.addr = 18446744073709547829LLU; // 99999999Dz'''''''''''''''
6295163169 break;
6295263170 }
62953- case 18446744073709547838LLU: // 99999999D8'''''''''''''''
63171+ case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
6295463172 {
6295563173 {
6295663174 uint64_t arg = 0;
@@ -62964,10 +63182,10 @@
6296463182 };
6296563183 *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = arg;
6296663184 }
62967- state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
63185+ state.addr = 18446744073709547826LLU; // 99999999Dw'''''''''''''''
6296863186 break;
6296963187 }
62970- case 18446744073709547835LLU: // 99999999D5'''''''''''''''
63188+ case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
6297163189 {
6297263190 {
6297363191 uint64_t arg = 0LLU;
@@ -63047,7 +63265,7 @@
6304763265 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6304863266 }
6304963267 // ACCUMULATE ARGUMENTS - END
63050- uint64_t return_to = 18446744073709547833LLU;
63268+ uint64_t return_to = 18446744073709547824LLU;
6305163269 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6305263270 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6305363271 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63056,12 +63274,12 @@
6305663274 state.addr = 787472342492567585LLU; // procvarref
6305763275 break;
6305863276 }
63059- case 18446744073709547833LLU: // 99999999D3'''''''''''''''
63277+ case 18446744073709547824LLU: // 99999999Du'''''''''''''''
6306063278 {
63061- state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
63279+ state.addr = 18446744073709547825LLU; // 99999999Dv'''''''''''''''
6306263280 break;
6306363281 }
63064- case 18446744073709547834LLU: // 99999999D4'''''''''''''''
63282+ case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
6306563283 {
6306663284 // ACCUMULATE ARGUMENTS - BEGIN
6306763285 {
@@ -63081,7 +63299,7 @@
6308163299 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6308263300 }
6308363301 // ACCUMULATE ARGUMENTS - END
63084- uint64_t return_to = 18446744073709547831LLU;
63302+ uint64_t return_to = 18446744073709547822LLU;
6308563303 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6308663304 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6308763305 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63090,12 +63308,12 @@
6309063308 state.addr = 861504774606571689LLU; // typeassign
6309163309 break;
6309263310 }
63093- case 18446744073709547831LLU: // 99999999D1'''''''''''''''
63311+ case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
6309463312 {
63095- state.addr = 18446744073709547832LLU; // 99999999D2'''''''''''''''
63313+ state.addr = 18446744073709547823LLU; // 99999999Dt'''''''''''''''
6309663314 break;
6309763315 }
63098- case 18446744073709547832LLU: // 99999999D2'''''''''''''''
63316+ case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
6309963317 {
6310063318 // variable u64 initialize goes out of scope
6310163319 // emitted destructur for type u64
@@ -63117,7 +63335,7 @@
6311763335 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6311863336 }
6311963337 // ACCUMULATE ARGUMENTS - END
63120- uint64_t return_to = 18446744073709547830LLU;
63338+ uint64_t return_to = 18446744073709547821LLU;
6312163339 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6312263340 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6312363341 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63126,13 +63344,13 @@
6312663344 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6312763345 break;
6312863346 }
63129- case 18446744073709547830LLU: // 99999999D0'''''''''''''''
63347+ case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
6313063348 {
6313163349 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 25
63132- state.addr = 18446744073709547836LLU; // 99999999D6'''''''''''''''
63350+ state.addr = 18446744073709547827LLU; // 99999999Dx'''''''''''''''
6313363351 break;
6313463352 }
63135- case 18446744073709547836LLU: // 99999999D6'''''''''''''''
63353+ case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
6313663354 {
6313763355 // ACCUMULATE ARGUMENTS - BEGIN
6313863356 {
@@ -63156,7 +63374,7 @@
6315663374 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6315763375 }
6315863376 // ACCUMULATE ARGUMENTS - END
63159- uint64_t return_to = 18446744073709547828LLU;
63377+ uint64_t return_to = 18446744073709547819LLU;
6316063378 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6316163379 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6316263380 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63165,12 +63383,12 @@
6316563383 state.addr = 890786842582581248LLU; // varclose__
6316663384 break;
6316763385 }
63168- case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
63386+ case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
6316963387 {
63170- state.addr = 18446744073709547829LLU; // 99999999Dz'''''''''''''''
63388+ state.addr = 18446744073709547820LLU; // 99999999Dq'''''''''''''''
6317163389 break;
6317263390 }
63173- case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
63391+ case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
6317463392 {
6317563393 {
6317663394 uint64_t arg = 0LLU;
@@ -63190,7 +63408,7 @@
6319063408 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6319163409 }
6319263410 // ACCUMULATE ARGUMENTS - END
63193- uint64_t return_to = 18446744073709547825LLU;
63411+ uint64_t return_to = 18446744073709547816LLU;
6319463412 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6319563413 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6319663414 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63199,12 +63417,12 @@
6319963417 state.addr = 661658442972266496LLU; // isprim____
6320063418 break;
6320163419 }
63202- case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
63420+ case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
6320363421 {
63204- state.addr = 18446744073709547826LLU; // 99999999Dw'''''''''''''''
63422+ state.addr = 18446744073709547817LLU; // 99999999Dn'''''''''''''''
6320563423 break;
6320663424 }
63207- case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
63425+ case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
6320863426 {
6320963427 {
6321063428 uint64_t arg = 0LLU;
@@ -63220,7 +63438,7 @@
6322063438 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6322163439 }
6322263440 // ACCUMULATE ARGUMENTS - END
63223- uint64_t return_to = 18446744073709547823LLU;
63441+ uint64_t return_to = 18446744073709547814LLU;
6322463442 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6322563443 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6322663444 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63229,12 +63447,12 @@
6322963447 state.addr = 367395560426147840LLU; // TYPECOPY__
6323063448 break;
6323163449 }
63232- case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
63450+ case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
6323363451 {
63234- state.addr = 18446744073709547824LLU; // 99999999Du'''''''''''''''
63452+ state.addr = 18446744073709547815LLU; // 99999999Dl'''''''''''''''
6323563453 break;
6323663454 }
63237- case 18446744073709547824LLU: // 99999999Du'''''''''''''''
63455+ case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
6323863456 {
6323963457 // ACCUMULATE ARGUMENTS - BEGIN
6324063458 {
@@ -63266,7 +63484,7 @@
6326663484 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6326763485 }
6326863486 // ACCUMULATE ARGUMENTS - END
63269- uint64_t return_to = 18446744073709547821LLU;
63487+ uint64_t return_to = 18446744073709547812LLU;
6327063488 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6327163489 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6327263490 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63275,12 +63493,12 @@
6327563493 state.addr = 788334703205941248LLU; // pushvar___
6327663494 break;
6327763495 }
63278- case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
63496+ case 18446744073709547812LLU: // 99999999Di'''''''''''''''
6327963497 {
63280- state.addr = 18446744073709547822LLU; // 99999999Ds'''''''''''''''
63498+ state.addr = 18446744073709547813LLU; // 99999999Dj'''''''''''''''
6328163499 break;
6328263500 }
63283- case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
63501+ case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
6328463502 {
6328563503 // variable type______ t_________ goes out of scope
6328663504 // emitted destructur for type type______
@@ -63290,7 +63508,7 @@
6329063508 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6329163509 }
6329263510 // ACCUMULATE ARGUMENTS - END
63293- uint64_t return_to = 18446744073709547820LLU;
63511+ uint64_t return_to = 18446744073709547811LLU;
6329463512 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6329563513 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6329663514 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63299,7 +63517,7 @@
6329963517 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6330063518 break;
6330163519 }
63302- case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
63520+ case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
6330363521 {
6330463522 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 27
6330563523 // variable u64 initialize goes out of scope
@@ -63308,18 +63526,18 @@
6330863526 // variable u64 INDIRECT__ goes out of scope
6330963527 // emitted destructur for type u64
6331063528 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 25
63311- state.addr = 18446744073709547827LLU; // 99999999Dx'''''''''''''''
63529+ state.addr = 18446744073709547818LLU; // 99999999Do'''''''''''''''
6331263530 break;
6331363531 }
63314- case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
63532+ case 18446744073709547818LLU: // 99999999Do'''''''''''''''
6331563533 {
6331663534 // variable u64 varidx____ goes out of scope
6331763535 // emitted destructur for type u64
6331863536 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 24
63319- state.addr = 18446744073709547839LLU; // 99999999D9'''''''''''''''
63537+ state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
6332063538 break;
6332163539 }
63322- case 18446744073709547839LLU: // 99999999D9'''''''''''''''
63540+ case 18446744073709547830LLU: // 99999999D0'''''''''''''''
6332363541 {
6332463542 // variable u64 notfound__ goes out of scope
6332563543 // emitted destructur for type u64
@@ -63330,23 +63548,23 @@
6333063548 // variable u64 INDIRECT__ goes out of scope
6333163549 // emitted destructur for type u64
6333263550 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 21
63333- state.addr = 18446744073709547861LLU; // 99999999EU'''''''''''''''
63551+ state.addr = 18446744073709547852LLU; // 99999999EL'''''''''''''''
6333463552 break;
6333563553 }
63336- case 18446744073709547861LLU: // 99999999EU'''''''''''''''
63554+ case 18446744073709547852LLU: // 99999999EL'''''''''''''''
6333763555 {
63338- state.addr = 18446744073709547886LLU; // 99999999Es'''''''''''''''
63556+ state.addr = 18446744073709547877LLU; // 99999999Ej'''''''''''''''
6333963557 break;
6334063558 }
63341- case 18446744073709547886LLU: // 99999999Es'''''''''''''''
63559+ case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
6334263560 {
6334363561 // variable u64 buf_______ goes out of scope
6334463562 // emitted destructur for type u64
6334563563 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference buf_______ at 20
63346- state.addr = 18446744073709547905LLU; // 99999999FA'''''''''''''''
63564+ state.addr = 18446744073709547896LLU; // 99999999E2'''''''''''''''
6334763565 break;
6334863566 }
63349- case 18446744073709547905LLU: // 99999999FA'''''''''''''''
63567+ case 18446744073709547896LLU: // 99999999E2'''''''''''''''
6335063568 {
6335163569 // variable u64 redef_____ goes out of scope
6335263570 // emitted destructur for type u64
@@ -63359,7 +63577,7 @@
6335963577 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6336063578 }
6336163579 // ACCUMULATE ARGUMENTS - END
63362- uint64_t return_to = 18446744073709547819LLU;
63580+ uint64_t return_to = 18446744073709547810LLU;
6336363581 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6336463582 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6336563583 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63368,7 +63586,7 @@
6336863586 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6336963587 break;
6337063588 }
63371- case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
63589+ case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
6337263590 {
6337363591 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedst___ at 18
6337463592 // variable u64 mutable___ goes out of scope
@@ -63424,10 +63642,10 @@
6342463642 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 876383386118840320LLU;
6342563643
6342663644 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
63427- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547818LLU : 18446744073709547817LLU;
63645+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547809LLU : 18446744073709547808LLU;
6342863646 break;
6342963647 }
63430- case 18446744073709547818LLU: // 99999999Do'''''''''''''''
63648+ case 18446744073709547809LLU: // 99999999Df'''''''''''''''
6343163649 {
6343263650 // ACCUMULATE ARGUMENTS - BEGIN
6343363651 {
@@ -63435,7 +63653,7 @@
6343563653 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6343663654 }
6343763655 // ACCUMULATE ARGUMENTS - END
63438- uint64_t return_to = 18446744073709547815LLU;
63656+ uint64_t return_to = 18446744073709547806LLU;
6343963657 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6344063658 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6344163659 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63444,12 +63662,12 @@
6344463662 state.addr = 839519719621918720LLU; // skipws____
6344563663 break;
6344663664 }
63447- case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
63665+ case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
6344863666 {
63449- state.addr = 18446744073709547816LLU; // 99999999Dm'''''''''''''''
63667+ state.addr = 18446744073709547807LLU; // 99999999Dd'''''''''''''''
6345063668 break;
6345163669 }
63452- case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
63670+ case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
6345363671 {
6345463672 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
6345563673 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63458,7 +63676,7 @@
6345863676 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6345963677 }
6346063678 // ACCUMULATE ARGUMENTS - END
63461- uint64_t return_to = 18446744073709547813LLU;
63679+ uint64_t return_to = 18446744073709547804LLU;
6346263680 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6346363681 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6346463682 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63467,12 +63685,12 @@
6346763685 state.addr = 839519719621918720LLU; // skipws____
6346863686 break;
6346963687 }
63470- case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
63688+ case 18446744073709547804LLU: // 99999999Da'''''''''''''''
6347163689 {
63472- state.addr = 18446744073709547814LLU; // 99999999Dk'''''''''''''''
63690+ state.addr = 18446744073709547805LLU; // 99999999Db'''''''''''''''
6347363691 break;
6347463692 }
63475- case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
63693+ case 18446744073709547805LLU: // 99999999Db'''''''''''''''
6347663694 {
6347763695 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
6347863696 if(')' != (char)getchar())
@@ -63483,18 +63701,18 @@
6348363701 fprintf(stdout, "%s", "\n ungetc(0, stdin);");
6348463702 heap.availilable_size_for_dynamic_objects += 0LLU;
6348563703 heap.availilable_size_for_dynamic_objects += 0LLU;
63486- state.addr = 18446744073709547812LLU; // 99999999Di'''''''''''''''
63704+ state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
6348763705 break;
6348863706 }
63489- case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
63707+ case 18446744073709547808LLU: // 99999999De'''''''''''''''
6349063708 {
6349163709 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 605666980531466240LLU;
6349263710
6349363711 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
63494- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547811LLU : 18446744073709547810LLU;
63712+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547802LLU : 18446744073709547801LLU;
6349563713 break;
6349663714 }
63497- case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
63715+ case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
6349863716 {
6349963717 // ACCUMULATE ARGUMENTS - BEGIN
6350063718 {
@@ -63502,7 +63720,7 @@
6350263720 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6350363721 }
6350463722 // ACCUMULATE ARGUMENTS - END
63505- uint64_t return_to = 18446744073709547808LLU;
63723+ uint64_t return_to = 18446744073709547799LLU;
6350663724 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6350763725 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6350863726 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63511,12 +63729,12 @@
6351163729 state.addr = 839519719621918720LLU; // skipws____
6351263730 break;
6351363731 }
63514- case 18446744073709547808LLU: // 99999999De'''''''''''''''
63732+ case 18446744073709547799LLU: // 99999999DW'''''''''''''''
6351563733 {
63516- state.addr = 18446744073709547809LLU; // 99999999Df'''''''''''''''
63734+ state.addr = 18446744073709547800LLU; // 99999999DX'''''''''''''''
6351763735 break;
6351863736 }
63519- case 18446744073709547809LLU: // 99999999Df'''''''''''''''
63737+ case 18446744073709547800LLU: // 99999999DX'''''''''''''''
6352063738 {
6352163739 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
6352263740 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63525,7 +63743,7 @@
6352563743 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6352663744 }
6352763745 // ACCUMULATE ARGUMENTS - END
63528- uint64_t return_to = 18446744073709547806LLU;
63746+ uint64_t return_to = 18446744073709547797LLU;
6352963747 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6353063748 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6353163749 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63534,12 +63752,12 @@
6353463752 state.addr = 839519719621918720LLU; // skipws____
6353563753 break;
6353663754 }
63537- case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
63755+ case 18446744073709547797LLU: // 99999999DU'''''''''''''''
6353863756 {
63539- state.addr = 18446744073709547807LLU; // 99999999Dd'''''''''''''''
63757+ state.addr = 18446744073709547798LLU; // 99999999DV'''''''''''''''
6354063758 break;
6354163759 }
63542- case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
63760+ case 18446744073709547798LLU: // 99999999DV'''''''''''''''
6354363761 {
6354463762 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
6354563763 if(')' != (char)getchar())
@@ -63550,20 +63768,20 @@
6355063768 fprintf(stdout, "%s", "\n fflush(stdout);");
6355163769 heap.availilable_size_for_dynamic_objects += 0LLU;
6355263770 heap.availilable_size_for_dynamic_objects += 0LLU;
63553- state.addr = 18446744073709547805LLU; // 99999999Db'''''''''''''''
63771+ state.addr = 18446744073709547796LLU; // 99999999DT'''''''''''''''
6355463772 break;
6355563773 }
63556- case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
63774+ case 18446744073709547801LLU: // 99999999DY'''''''''''''''
6355763775 {
63558- state.addr = 18446744073709547805LLU; // 99999999Db'''''''''''''''
63776+ state.addr = 18446744073709547796LLU; // 99999999DT'''''''''''''''
6355963777 break;
6356063778 }
63561- case 18446744073709547805LLU: // 99999999Db'''''''''''''''
63779+ case 18446744073709547796LLU: // 99999999DT'''''''''''''''
6356263780 {
63563- state.addr = 18446744073709547812LLU; // 99999999Di'''''''''''''''
63781+ state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
6356463782 break;
6356563783 }
63566- case 18446744073709547812LLU: // 99999999Di'''''''''''''''
63784+ case 18446744073709547803LLU: // 99999999D$'''''''''''''''
6356763785 {
6356863786 // variable u64 sym_______ goes out of scope
6356963787 // emitted destructur for type u64
@@ -63613,10 +63831,10 @@
6361363831 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183514351405LLU;
6361463832
6361563833 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
63616- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547804LLU : 18446744073709547803LLU;
63834+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547795LLU : 18446744073709547794LLU;
6361763835 break;
6361863836 }
63619- case 18446744073709547804LLU: // 99999999Da'''''''''''''''
63837+ case 18446744073709547795LLU: // 99999999DS'''''''''''''''
6362063838 {
6362163839 {
6362263840 uint64_t arg = 0LLU;
@@ -63638,10 +63856,10 @@
6363863856 };
6363963857 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6364063858 }
63641- state.addr = 18446744073709547802LLU; // 99999999DZ'''''''''''''''
63859+ state.addr = 18446744073709547793LLU; // 99999999DQ'''''''''''''''
6364263860 break;
6364363861 }
63644- case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
63862+ case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
6364563863 {
6364663864 // ACCUMULATE ARGUMENTS - BEGIN
6364763865 {
@@ -63649,7 +63867,7 @@
6364963867 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6365063868 }
6365163869 // ACCUMULATE ARGUMENTS - END
63652- uint64_t return_to = 18446744073709547800LLU;
63870+ uint64_t return_to = 18446744073709547791LLU;
6365363871 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6365463872 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6365563873 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63658,12 +63876,12 @@
6365863876 state.addr = 839519719621918720LLU; // skipws____
6365963877 break;
6366063878 }
63661- case 18446744073709547800LLU: // 99999999DX'''''''''''''''
63879+ case 18446744073709547791LLU: // 99999999DO'''''''''''''''
6366263880 {
63663- state.addr = 18446744073709547801LLU; // 99999999DY'''''''''''''''
63881+ state.addr = 18446744073709547792LLU; // 99999999DP'''''''''''''''
6366463882 break;
6366563883 }
63666- case 18446744073709547801LLU: // 99999999DY'''''''''''''''
63884+ case 18446744073709547792LLU: // 99999999DP'''''''''''''''
6366763885 {
6366863886 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6366963887 fprintf(stdout, "%s", "\n putc((char)");
@@ -63677,7 +63895,7 @@
6367763895 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6367863896 }
6367963897 // ACCUMULATE ARGUMENTS - END
63680- uint64_t return_to = 18446744073709547797LLU;
63898+ uint64_t return_to = 18446744073709547788LLU;
6368163899 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6368263900 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6368363901 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63686,12 +63904,12 @@
6368663904 state.addr = 839519719621918720LLU; // skipws____
6368763905 break;
6368863906 }
63689- case 18446744073709547797LLU: // 99999999DU'''''''''''''''
63907+ case 18446744073709547788LLU: // 99999999DL'''''''''''''''
6369063908 {
63691- state.addr = 18446744073709547798LLU; // 99999999DV'''''''''''''''
63909+ state.addr = 18446744073709547789LLU; // 99999999DM'''''''''''''''
6369263910 break;
6369363911 }
63694- case 18446744073709547798LLU: // 99999999DV'''''''''''''''
63912+ case 18446744073709547789LLU: // 99999999DM'''''''''''''''
6369563913 {
6369663914 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6369763915 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63712,7 +63930,7 @@
6371263930 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6371363931 }
6371463932 // ACCUMULATE ARGUMENTS - END
63715- uint64_t return_to = 18446744073709547795LLU;
63933+ uint64_t return_to = 18446744073709547786LLU;
6371663934 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6371763935 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6371863936 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63721,12 +63939,12 @@
6372163939 state.addr = 517555565473470767LLU; // assertinit
6372263940 break;
6372363941 }
63724- case 18446744073709547795LLU: // 99999999DS'''''''''''''''
63942+ case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
6372563943 {
63726- state.addr = 18446744073709547796LLU; // 99999999DT'''''''''''''''
63944+ state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
6372763945 break;
6372863946 }
63729- case 18446744073709547796LLU: // 99999999DT'''''''''''''''
63947+ case 18446744073709547787LLU: // 99999999DK'''''''''''''''
6373063948 {
6373163949 {
6373263950 uint64_t arg = 0LLU;
@@ -63802,7 +64020,7 @@
6380264020 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6380364021 }
6380464022 // ACCUMULATE ARGUMENTS - END
63805- uint64_t return_to = 18446744073709547793LLU;
64023+ uint64_t return_to = 18446744073709547784LLU;
6380664024 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6380764025 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6380864026 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63811,12 +64029,12 @@
6381164029 state.addr = 787472342492567585LLU; // procvarref
6381264030 break;
6381364031 }
63814- case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
64032+ case 18446744073709547784LLU: // 99999999DH'''''''''''''''
6381564033 {
63816- state.addr = 18446744073709547794LLU; // 99999999DR'''''''''''''''
64034+ state.addr = 18446744073709547785LLU; // 99999999DI'''''''''''''''
6381764035 break;
6381864036 }
63819- case 18446744073709547794LLU: // 99999999DR'''''''''''''''
64037+ case 18446744073709547785LLU: // 99999999DI'''''''''''''''
6382064038 {
6382164039 // variable u64 initialize goes out of scope
6382264040 // emitted destructur for type u64
@@ -63827,10 +64045,10 @@
6382764045 // variable u64 idx_______ goes out of scope
6382864046 // emitted destructur for type u64
6382964047 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
63830- state.addr = 18446744073709547799LLU; // 99999999DW'''''''''''''''
64048+ state.addr = 18446744073709547790LLU; // 99999999DN'''''''''''''''
6383164049 break;
6383264050 }
63833- case 18446744073709547799LLU: // 99999999DW'''''''''''''''
64051+ case 18446744073709547790LLU: // 99999999DN'''''''''''''''
6383464052 {
6383564053 fprintf(stdout, "%s", ", stderr);");
6383664054 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63839,7 +64057,7 @@
6383964057 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6384064058 }
6384164059 // ACCUMULATE ARGUMENTS - END
63842- uint64_t return_to = 18446744073709547791LLU;
64060+ uint64_t return_to = 18446744073709547782LLU;
6384364061 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6384464062 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6384564063 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63848,12 +64066,12 @@
6384864066 state.addr = 839519719621918720LLU; // skipws____
6384964067 break;
6385064068 }
63851- case 18446744073709547791LLU: // 99999999DO'''''''''''''''
64069+ case 18446744073709547782LLU: // 99999999DF'''''''''''''''
6385264070 {
63853- state.addr = 18446744073709547792LLU; // 99999999DP'''''''''''''''
64071+ state.addr = 18446744073709547783LLU; // 99999999DG'''''''''''''''
6385464072 break;
6385564073 }
63856- case 18446744073709547792LLU: // 99999999DP'''''''''''''''
64074+ case 18446744073709547783LLU: // 99999999DG'''''''''''''''
6385764075 {
6385864076 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6385964077 if(')' != (char)getchar())
@@ -63871,7 +64089,7 @@
6387164089 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6387264090 }
6387364091 // ACCUMULATE ARGUMENTS - END
63874- uint64_t return_to = 18446744073709547789LLU;
64092+ uint64_t return_to = 18446744073709547780LLU;
6387564093 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6387664094 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6387764095 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63880,12 +64098,12 @@
6388064098 state.addr = 517555565476695680LLU; // assertu64_
6388164099 break;
6388264100 }
63883- case 18446744073709547789LLU: // 99999999DM'''''''''''''''
64101+ case 18446744073709547780LLU: // 99999999DD'''''''''''''''
6388464102 {
63885- state.addr = 18446744073709547790LLU; // 99999999DN'''''''''''''''
64103+ state.addr = 18446744073709547781LLU; // 99999999DE'''''''''''''''
6388664104 break;
6388764105 }
63888- case 18446744073709547790LLU: // 99999999DN'''''''''''''''
64106+ case 18446744073709547781LLU: // 99999999DE'''''''''''''''
6388964107 {
6389064108 // variable u64 mutable___ goes out of scope
6389164109 // emitted destructur for type u64
@@ -63898,7 +64116,7 @@
6389864116 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6389964117 }
6390064118 // ACCUMULATE ARGUMENTS - END
63901- uint64_t return_to = 18446744073709547788LLU;
64119+ uint64_t return_to = 18446744073709547779LLU;
6390264120 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6390364121 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6390464122 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63907,7 +64125,7 @@
6390764125 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6390864126 break;
6390964127 }
63910- case 18446744073709547788LLU: // 99999999DL'''''''''''''''
64128+ case 18446744073709547779LLU: // 99999999DC'''''''''''''''
6391164129 {
6391264130 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6391364131 // variable u64 INDIRECT__ goes out of scope
@@ -63918,18 +64136,18 @@
6391864136 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6391964137 heap.availilable_size_for_dynamic_objects += 0LLU;
6392064138 heap.availilable_size_for_dynamic_objects += 0LLU;
63921- state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
64139+ state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
6392264140 break;
6392364141 }
63924- case 18446744073709547803LLU: // 99999999D$'''''''''''''''
64142+ case 18446744073709547794LLU: // 99999999DR'''''''''''''''
6392564143 {
6392664144 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708011125568LLU;
6392764145
6392864146 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
63929- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547786LLU : 18446744073709547785LLU;
64147+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547777LLU : 18446744073709547776LLU;
6393064148 break;
6393164149 }
63932- case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
64150+ case 18446744073709547777LLU: // 99999999DA'''''''''''''''
6393364151 {
6393464152 {
6393564153 uint64_t arg = 0LLU;
@@ -63951,10 +64169,10 @@
6395164169 };
6395264170 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6395364171 }
63954- state.addr = 18446744073709547784LLU; // 99999999DH'''''''''''''''
64172+ state.addr = 18446744073709547775LLU; // 99999999C9'''''''''''''''
6395564173 break;
6395664174 }
63957- case 18446744073709547784LLU: // 99999999DH'''''''''''''''
64175+ case 18446744073709547775LLU: // 99999999C9'''''''''''''''
6395864176 {
6395964177 // ACCUMULATE ARGUMENTS - BEGIN
6396064178 {
@@ -63962,7 +64180,7 @@
6396264180 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6396364181 }
6396464182 // ACCUMULATE ARGUMENTS - END
63965- uint64_t return_to = 18446744073709547782LLU;
64183+ uint64_t return_to = 18446744073709547773LLU;
6396664184 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6396764185 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6396864186 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63971,12 +64189,12 @@
6397164189 state.addr = 839519719621918720LLU; // skipws____
6397264190 break;
6397364191 }
63974- case 18446744073709547782LLU: // 99999999DF'''''''''''''''
64192+ case 18446744073709547773LLU: // 99999999C7'''''''''''''''
6397564193 {
63976- state.addr = 18446744073709547783LLU; // 99999999DG'''''''''''''''
64194+ state.addr = 18446744073709547774LLU; // 99999999C8'''''''''''''''
6397764195 break;
6397864196 }
63979- case 18446744073709547783LLU: // 99999999DG'''''''''''''''
64197+ case 18446744073709547774LLU: // 99999999C8'''''''''''''''
6398064198 {
6398164199 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6398264200 fprintf(stdout, "%s", "\n putc((char)");
@@ -63990,7 +64208,7 @@
6399064208 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6399164209 }
6399264210 // ACCUMULATE ARGUMENTS - END
63993- uint64_t return_to = 18446744073709547779LLU;
64211+ uint64_t return_to = 18446744073709547770LLU;
6399464212 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6399564213 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6399664214 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63999,12 +64217,12 @@
6399964217 state.addr = 839519719621918720LLU; // skipws____
6400064218 break;
6400164219 }
64002- case 18446744073709547779LLU: // 99999999DC'''''''''''''''
64220+ case 18446744073709547770LLU: // 99999999C4'''''''''''''''
6400364221 {
64004- state.addr = 18446744073709547780LLU; // 99999999DD'''''''''''''''
64222+ state.addr = 18446744073709547771LLU; // 99999999C5'''''''''''''''
6400564223 break;
6400664224 }
64007- case 18446744073709547780LLU: // 99999999DD'''''''''''''''
64225+ case 18446744073709547771LLU: // 99999999C5'''''''''''''''
6400864226 {
6400964227 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6401064228 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64025,7 +64243,7 @@
6402564243 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6402664244 }
6402764245 // ACCUMULATE ARGUMENTS - END
64028- uint64_t return_to = 18446744073709547777LLU;
64246+ uint64_t return_to = 18446744073709547768LLU;
6402964247 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6403064248 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6403164249 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64034,12 +64252,12 @@
6403464252 state.addr = 517555565473470767LLU; // assertinit
6403564253 break;
6403664254 }
64037- case 18446744073709547777LLU: // 99999999DA'''''''''''''''
64255+ case 18446744073709547768LLU: // 99999999C2'''''''''''''''
6403864256 {
64039- state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
64257+ state.addr = 18446744073709547769LLU; // 99999999C3'''''''''''''''
6404064258 break;
6404164259 }
64042- case 18446744073709547778LLU: // 99999999DB'''''''''''''''
64260+ case 18446744073709547769LLU: // 99999999C3'''''''''''''''
6404364261 {
6404464262 {
6404564263 uint64_t arg = 0LLU;
@@ -64115,7 +64333,7 @@
6411564333 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6411664334 }
6411764335 // ACCUMULATE ARGUMENTS - END
64118- uint64_t return_to = 18446744073709547775LLU;
64336+ uint64_t return_to = 18446744073709547766LLU;
6411964337 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6412064338 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6412164339 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64124,12 +64342,12 @@
6412464342 state.addr = 787472342492567585LLU; // procvarref
6412564343 break;
6412664344 }
64127- case 18446744073709547775LLU: // 99999999C9'''''''''''''''
64345+ case 18446744073709547766LLU: // 99999999C0'''''''''''''''
6412864346 {
64129- state.addr = 18446744073709547776LLU; // 99999999D_'''''''''''''''
64347+ state.addr = 18446744073709547767LLU; // 99999999C1'''''''''''''''
6413064348 break;
6413164349 }
64132- case 18446744073709547776LLU: // 99999999D_'''''''''''''''
64350+ case 18446744073709547767LLU: // 99999999C1'''''''''''''''
6413364351 {
6413464352 // variable u64 initialize goes out of scope
6413564353 // emitted destructur for type u64
@@ -64140,10 +64358,10 @@
6414064358 // variable u64 idx_______ goes out of scope
6414164359 // emitted destructur for type u64
6414264360 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
64143- state.addr = 18446744073709547781LLU; // 99999999DE'''''''''''''''
64361+ state.addr = 18446744073709547772LLU; // 99999999C6'''''''''''''''
6414464362 break;
6414564363 }
64146- case 18446744073709547781LLU: // 99999999DE'''''''''''''''
64364+ case 18446744073709547772LLU: // 99999999C6'''''''''''''''
6414764365 {
6414864366 fprintf(stdout, "%s", ", stdout);");
6414964367 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64152,7 +64370,7 @@
6415264370 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6415364371 }
6415464372 // ACCUMULATE ARGUMENTS - END
64155- uint64_t return_to = 18446744073709547773LLU;
64373+ uint64_t return_to = 18446744073709547764LLU;
6415664374 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6415764375 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6415864376 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64161,12 +64379,12 @@
6416164379 state.addr = 839519719621918720LLU; // skipws____
6416264380 break;
6416364381 }
64164- case 18446744073709547773LLU: // 99999999C7'''''''''''''''
64382+ case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
6416564383 {
64166- state.addr = 18446744073709547774LLU; // 99999999C8'''''''''''''''
64384+ state.addr = 18446744073709547765LLU; // 99999999Cz'''''''''''''''
6416764385 break;
6416864386 }
64169- case 18446744073709547774LLU: // 99999999C8'''''''''''''''
64387+ case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
6417064388 {
6417164389 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6417264390 if(')' != (char)getchar())
@@ -64184,7 +64402,7 @@
6418464402 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6418564403 }
6418664404 // ACCUMULATE ARGUMENTS - END
64187- uint64_t return_to = 18446744073709547771LLU;
64405+ uint64_t return_to = 18446744073709547762LLU;
6418864406 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6418964407 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6419064408 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64193,12 +64411,12 @@
6419364411 state.addr = 517555565476695680LLU; // assertu64_
6419464412 break;
6419564413 }
64196- case 18446744073709547771LLU: // 99999999C5'''''''''''''''
64414+ case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
6419764415 {
64198- state.addr = 18446744073709547772LLU; // 99999999C6'''''''''''''''
64416+ state.addr = 18446744073709547763LLU; // 99999999Cx'''''''''''''''
6419964417 break;
6420064418 }
64201- case 18446744073709547772LLU: // 99999999C6'''''''''''''''
64419+ case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
6420264420 {
6420364421 // variable u64 mutable___ goes out of scope
6420464422 // emitted destructur for type u64
@@ -64211,7 +64429,7 @@
6421164429 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6421264430 }
6421364431 // ACCUMULATE ARGUMENTS - END
64214- uint64_t return_to = 18446744073709547770LLU;
64432+ uint64_t return_to = 18446744073709547761LLU;
6421564433 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6421664434 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6421764435 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64220,7 +64438,7 @@
6422064438 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6422164439 break;
6422264440 }
64223- case 18446744073709547770LLU: // 99999999C4'''''''''''''''
64441+ case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
6422464442 {
6422564443 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6422664444 // variable u64 INDIRECT__ goes out of scope
@@ -64231,18 +64449,18 @@
6423164449 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6423264450 heap.availilable_size_for_dynamic_objects += 0LLU;
6423364451 heap.availilable_size_for_dynamic_objects += 0LLU;
64234- state.addr = 18446744073709547769LLU; // 99999999C3'''''''''''''''
64452+ state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
6423564453 break;
6423664454 }
64237- case 18446744073709547785LLU: // 99999999DI'''''''''''''''
64455+ case 18446744073709547776LLU: // 99999999D_'''''''''''''''
6423864456 {
6423964457 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 621705556409974784LLU;
6424064458
6424164459 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64242- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547768LLU : 18446744073709547767LLU;
64460+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547759LLU : 18446744073709547758LLU;
6424364461 break;
6424464462 }
64245- case 18446744073709547768LLU: // 99999999C2'''''''''''''''
64463+ case 18446744073709547759LLU: // 99999999Ct'''''''''''''''
6424664464 {
6424764465 {
6424864466 uint64_t arg = 0LLU;
@@ -64264,10 +64482,10 @@
6426464482 };
6426564483 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6426664484 }
64267- state.addr = 18446744073709547766LLU; // 99999999C0'''''''''''''''
64485+ state.addr = 18446744073709547757LLU; // 99999999Cr'''''''''''''''
6426864486 break;
6426964487 }
64270- case 18446744073709547766LLU: // 99999999C0'''''''''''''''
64488+ case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
6427164489 {
6427264490 // ACCUMULATE ARGUMENTS - BEGIN
6427364491 {
@@ -64275,7 +64493,7 @@
6427564493 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6427664494 }
6427764495 // ACCUMULATE ARGUMENTS - END
64278- uint64_t return_to = 18446744073709547764LLU;
64496+ uint64_t return_to = 18446744073709547755LLU;
6427964497 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6428064498 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6428164499 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64284,12 +64502,12 @@
6428464502 state.addr = 839519719621918720LLU; // skipws____
6428564503 break;
6428664504 }
64287- case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
64505+ case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
6428864506 {
64289- state.addr = 18446744073709547765LLU; // 99999999Cz'''''''''''''''
64507+ state.addr = 18446744073709547756LLU; // 99999999Cq'''''''''''''''
6429064508 break;
6429164509 }
64292- case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
64510+ case 18446744073709547756LLU: // 99999999Cq'''''''''''''''
6429364511 {
6429464512 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6429564513 fprintf(stdout, "%s", "\n ");
@@ -64303,7 +64521,7 @@
6430364521 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6430464522 }
6430564523 // ACCUMULATE ARGUMENTS - END
64306- uint64_t return_to = 18446744073709547761LLU;
64524+ uint64_t return_to = 18446744073709547752LLU;
6430764525 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6430864526 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6430964527 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64312,12 +64530,12 @@
6431264530 state.addr = 839519719621918720LLU; // skipws____
6431364531 break;
6431464532 }
64315- case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
64533+ case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
6431664534 {
64317- state.addr = 18446744073709547762LLU; // 99999999Cw'''''''''''''''
64535+ state.addr = 18446744073709547753LLU; // 99999999Cn'''''''''''''''
6431864536 break;
6431964537 }
64320- case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
64538+ case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
6432164539 {
6432264540 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6432364541 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64338,7 +64556,7 @@
6433864556 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6433964557 }
6434064558 // ACCUMULATE ARGUMENTS - END
64341- uint64_t return_to = 18446744073709547759LLU;
64559+ uint64_t return_to = 18446744073709547750LLU;
6434264560 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6434364561 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6434464562 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64347,12 +64565,12 @@
6434764565 state.addr = 517555565473470767LLU; // assertinit
6434864566 break;
6434964567 }
64350- case 18446744073709547759LLU: // 99999999Ct'''''''''''''''
64568+ case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
6435164569 {
64352- state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
64570+ state.addr = 18446744073709547751LLU; // 99999999Cl'''''''''''''''
6435364571 break;
6435464572 }
64355- case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
64573+ case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
6435664574 {
6435764575 {
6435864576 uint64_t arg = 0LLU;
@@ -64428,7 +64646,7 @@
6442864646 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6442964647 }
6443064648 // ACCUMULATE ARGUMENTS - END
64431- uint64_t return_to = 18446744073709547757LLU;
64649+ uint64_t return_to = 18446744073709547748LLU;
6443264650 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6443364651 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6443464652 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64437,12 +64655,12 @@
6443764655 state.addr = 787472342492567585LLU; // procvarref
6443864656 break;
6443964657 }
64440- case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
64658+ case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
6444164659 {
64442- state.addr = 18446744073709547758LLU; // 99999999Cs'''''''''''''''
64660+ state.addr = 18446744073709547749LLU; // 99999999Cj'''''''''''''''
6444364661 break;
6444464662 }
64445- case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
64663+ case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
6444664664 {
6444764665 // variable u64 initialize goes out of scope
6444864666 // emitted destructur for type u64
@@ -64453,10 +64671,10 @@
6445364671 // variable u64 idx_______ goes out of scope
6445464672 // emitted destructur for type u64
6445564673 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
64456- state.addr = 18446744073709547763LLU; // 99999999Cx'''''''''''''''
64674+ state.addr = 18446744073709547754LLU; // 99999999Co'''''''''''''''
6445764675 break;
6445864676 }
64459- case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
64677+ case 18446744073709547754LLU: // 99999999Co'''''''''''''''
6446064678 {
6446164679 fprintf(stdout, "%s", " = (uint64_t)getchar();");
6446264680 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64465,7 +64683,7 @@
6446564683 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6446664684 }
6446764685 // ACCUMULATE ARGUMENTS - END
64468- uint64_t return_to = 18446744073709547755LLU;
64686+ uint64_t return_to = 18446744073709547746LLU;
6446964687 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6447064688 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6447164689 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64474,12 +64692,12 @@
6447464692 state.addr = 839519719621918720LLU; // skipws____
6447564693 break;
6447664694 }
64477- case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
64695+ case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
6447864696 {
64479- state.addr = 18446744073709547756LLU; // 99999999Cq'''''''''''''''
64697+ state.addr = 18446744073709547747LLU; // 99999999Ch'''''''''''''''
6448064698 break;
6448164699 }
64482- case 18446744073709547756LLU: // 99999999Cq'''''''''''''''
64700+ case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
6448364701 {
6448464702 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6448564703 if(')' != (char)getchar())
@@ -64497,7 +64715,7 @@
6449764715 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6449864716 }
6449964717 // ACCUMULATE ARGUMENTS - END
64500- uint64_t return_to = 18446744073709547753LLU;
64718+ uint64_t return_to = 18446744073709547744LLU;
6450164719 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6450264720 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6450364721 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64506,12 +64724,12 @@
6450664724 state.addr = 517555565476695680LLU; // assertu64_
6450764725 break;
6450864726 }
64509- case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
64727+ case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
6451064728 {
64511- state.addr = 18446744073709547754LLU; // 99999999Co'''''''''''''''
64729+ state.addr = 18446744073709547745LLU; // 99999999Cf'''''''''''''''
6451264730 break;
6451364731 }
64514- case 18446744073709547754LLU: // 99999999Co'''''''''''''''
64732+ case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
6451564733 {
6451664734 {
6451764735 uint64_t arg = 1LLU;
@@ -64539,7 +64757,7 @@
6453964757 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6454064758 }
6454164759 // ACCUMULATE ARGUMENTS - END
64542- uint64_t return_to = 18446744073709547750LLU;
64760+ uint64_t return_to = 18446744073709547741LLU;
6454364761 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6454464762 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6454564763 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64548,20 +64766,20 @@
6454864766 state.addr = 734295421765213120LLU; // mutassert_
6454964767 break;
6455064768 }
64551- case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
64769+ case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
6455264770 {
64553- state.addr = 18446744073709547751LLU; // 99999999Cl'''''''''''''''
64771+ state.addr = 18446744073709547742LLU; // 99999999Cc'''''''''''''''
6455464772 break;
6455564773 }
64556- case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
64774+ case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
6455764775 {
6455864776 // variable u64 parnr_____ goes out of scope
6455964777 // emitted destructur for type u64
6456064778 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
64561- state.addr = 18446744073709547752LLU; // 99999999Cm'''''''''''''''
64779+ state.addr = 18446744073709547743LLU; // 99999999Cd'''''''''''''''
6456264780 break;
6456364781 }
64564- case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
64782+ case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
6456564783 {
6456664784 // variable u64 mutable___ goes out of scope
6456764785 // emitted destructur for type u64
@@ -64574,7 +64792,7 @@
6457464792 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6457564793 }
6457664794 // ACCUMULATE ARGUMENTS - END
64577- uint64_t return_to = 18446744073709547749LLU;
64795+ uint64_t return_to = 18446744073709547740LLU;
6457864796 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6457964797 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6458064798 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64583,7 +64801,7 @@
6458364801 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6458464802 break;
6458564803 }
64586- case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
64804+ case 18446744073709547740LLU: // 99999999Ca'''''''''''''''
6458764805 {
6458864806 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6458964807 // variable u64 INDIRECT__ goes out of scope
@@ -64594,18 +64812,18 @@
6459464812 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6459564813 heap.availilable_size_for_dynamic_objects += 0LLU;
6459664814 heap.availilable_size_for_dynamic_objects += 0LLU;
64597- state.addr = 18446744073709547748LLU; // 99999999Ci'''''''''''''''
64815+ state.addr = 18446744073709547739LLU; // 99999999C$'''''''''''''''
6459864816 break;
6459964817 }
64600- case 18446744073709547767LLU: // 99999999C1'''''''''''''''
64818+ case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
6460164819 {
6460264820 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 783769716797919232LLU;
6460364821
6460464822 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64605- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547747LLU : 18446744073709547746LLU;
64823+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547738LLU : 18446744073709547737LLU;
6460664824 break;
6460764825 }
64608- case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
64826+ case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
6460964827 {
6461064828 {
6461164829 uint64_t arg = 0LLU;
@@ -64627,10 +64845,10 @@
6462764845 };
6462864846 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6462964847 }
64630- state.addr = 18446744073709547745LLU; // 99999999Cf'''''''''''''''
64848+ state.addr = 18446744073709547736LLU; // 99999999CX'''''''''''''''
6463164849 break;
6463264850 }
64633- case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
64851+ case 18446744073709547736LLU: // 99999999CX'''''''''''''''
6463464852 {
6463564853 // ACCUMULATE ARGUMENTS - BEGIN
6463664854 {
@@ -64638,7 +64856,7 @@
6463864856 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6463964857 }
6464064858 // ACCUMULATE ARGUMENTS - END
64641- uint64_t return_to = 18446744073709547743LLU;
64859+ uint64_t return_to = 18446744073709547734LLU;
6464264860 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6464364861 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6464464862 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64647,12 +64865,12 @@
6464764865 state.addr = 839519719621918720LLU; // skipws____
6464864866 break;
6464964867 }
64650- case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
64868+ case 18446744073709547734LLU: // 99999999CV'''''''''''''''
6465164869 {
64652- state.addr = 18446744073709547744LLU; // 99999999Ce'''''''''''''''
64870+ state.addr = 18446744073709547735LLU; // 99999999CW'''''''''''''''
6465364871 break;
6465464872 }
64655- case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
64873+ case 18446744073709547735LLU: // 99999999CW'''''''''''''''
6465664874 {
6465764875 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6465864876 fprintf(stdout, "%s", "\n ");
@@ -64666,7 +64884,7 @@
6466664884 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6466764885 }
6466864886 // ACCUMULATE ARGUMENTS - END
64669- uint64_t return_to = 18446744073709547740LLU;
64887+ uint64_t return_to = 18446744073709547731LLU;
6467064888 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6467164889 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6467264890 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64675,12 +64893,12 @@
6467564893 state.addr = 839519719621918720LLU; // skipws____
6467664894 break;
6467764895 }
64678- case 18446744073709547740LLU: // 99999999Ca'''''''''''''''
64896+ case 18446744073709547731LLU: // 99999999CS'''''''''''''''
6467964897 {
64680- state.addr = 18446744073709547741LLU; // 99999999Cb'''''''''''''''
64898+ state.addr = 18446744073709547732LLU; // 99999999CT'''''''''''''''
6468164899 break;
6468264900 }
64683- case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
64901+ case 18446744073709547732LLU: // 99999999CT'''''''''''''''
6468464902 {
6468564903 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6468664904 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64701,7 +64919,7 @@
6470164919 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6470264920 }
6470364921 // ACCUMULATE ARGUMENTS - END
64704- uint64_t return_to = 18446744073709547738LLU;
64922+ uint64_t return_to = 18446744073709547729LLU;
6470564923 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6470664924 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6470764925 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64710,12 +64928,12 @@
6471064928 state.addr = 517555565473470767LLU; // assertinit
6471164929 break;
6471264930 }
64713- case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
64931+ case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
6471464932 {
64715- state.addr = 18446744073709547739LLU; // 99999999C$'''''''''''''''
64933+ state.addr = 18446744073709547730LLU; // 99999999CR'''''''''''''''
6471664934 break;
6471764935 }
64718- case 18446744073709547739LLU: // 99999999C$'''''''''''''''
64936+ case 18446744073709547730LLU: // 99999999CR'''''''''''''''
6471964937 {
6472064938 {
6472164939 uint64_t arg = 0LLU;
@@ -64791,7 +65009,7 @@
6479165009 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6479265010 }
6479365011 // ACCUMULATE ARGUMENTS - END
64794- uint64_t return_to = 18446744073709547736LLU;
65012+ uint64_t return_to = 18446744073709547727LLU;
6479565013 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6479665014 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6479765015 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64800,12 +65018,12 @@
6480065018 state.addr = 787472342492567585LLU; // procvarref
6480165019 break;
6480265020 }
64803- case 18446744073709547736LLU: // 99999999CX'''''''''''''''
65021+ case 18446744073709547727LLU: // 99999999CO'''''''''''''''
6480465022 {
64805- state.addr = 18446744073709547737LLU; // 99999999CY'''''''''''''''
65023+ state.addr = 18446744073709547728LLU; // 99999999CP'''''''''''''''
6480665024 break;
6480765025 }
64808- case 18446744073709547737LLU: // 99999999CY'''''''''''''''
65026+ case 18446744073709547728LLU: // 99999999CP'''''''''''''''
6480965027 {
6481065028 // variable u64 initialize goes out of scope
6481165029 // emitted destructur for type u64
@@ -64816,10 +65034,10 @@
6481665034 // variable u64 idx_______ goes out of scope
6481765035 // emitted destructur for type u64
6481865036 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
64819- state.addr = 18446744073709547742LLU; // 99999999Cc'''''''''''''''
65037+ state.addr = 18446744073709547733LLU; // 99999999CU'''''''''''''''
6482065038 break;
6482165039 }
64822- case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
65040+ case 18446744073709547733LLU: // 99999999CU'''''''''''''''
6482365041 {
6482465042 fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
6482565043 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64828,7 +65046,7 @@
6482865046 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6482965047 }
6483065048 // ACCUMULATE ARGUMENTS - END
64831- uint64_t return_to = 18446744073709547734LLU;
65049+ uint64_t return_to = 18446744073709547725LLU;
6483265050 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6483365051 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6483465052 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64837,12 +65055,12 @@
6483765055 state.addr = 839519719621918720LLU; // skipws____
6483865056 break;
6483965057 }
64840- case 18446744073709547734LLU: // 99999999CV'''''''''''''''
65058+ case 18446744073709547725LLU: // 99999999CM'''''''''''''''
6484165059 {
64842- state.addr = 18446744073709547735LLU; // 99999999CW'''''''''''''''
65060+ state.addr = 18446744073709547726LLU; // 99999999CN'''''''''''''''
6484365061 break;
6484465062 }
64845- case 18446744073709547735LLU: // 99999999CW'''''''''''''''
65063+ case 18446744073709547726LLU: // 99999999CN'''''''''''''''
6484665064 {
6484765065 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6484865066 if(')' != (char)getchar())
@@ -64860,7 +65078,7 @@
6486065078 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6486165079 }
6486265080 // ACCUMULATE ARGUMENTS - END
64863- uint64_t return_to = 18446744073709547732LLU;
65081+ uint64_t return_to = 18446744073709547723LLU;
6486465082 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6486565083 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6486665084 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64869,12 +65087,12 @@
6486965087 state.addr = 517555565476695680LLU; // assertu64_
6487065088 break;
6487165089 }
64872- case 18446744073709547732LLU: // 99999999CT'''''''''''''''
65090+ case 18446744073709547723LLU: // 99999999CK'''''''''''''''
6487365091 {
64874- state.addr = 18446744073709547733LLU; // 99999999CU'''''''''''''''
65092+ state.addr = 18446744073709547724LLU; // 99999999CL'''''''''''''''
6487565093 break;
6487665094 }
64877- case 18446744073709547733LLU: // 99999999CU'''''''''''''''
65095+ case 18446744073709547724LLU: // 99999999CL'''''''''''''''
6487865096 {
6487965097 {
6488065098 uint64_t arg = 1LLU;
@@ -64902,7 +65120,7 @@
6490265120 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6490365121 }
6490465122 // ACCUMULATE ARGUMENTS - END
64905- uint64_t return_to = 18446744073709547729LLU;
65123+ uint64_t return_to = 18446744073709547720LLU;
6490665124 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6490765125 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6490865126 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64911,20 +65129,20 @@
6491165129 state.addr = 734295421765213120LLU; // mutassert_
6491265130 break;
6491365131 }
64914- case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
65132+ case 18446744073709547720LLU: // 99999999CH'''''''''''''''
6491565133 {
64916- state.addr = 18446744073709547730LLU; // 99999999CR'''''''''''''''
65134+ state.addr = 18446744073709547721LLU; // 99999999CI'''''''''''''''
6491765135 break;
6491865136 }
64919- case 18446744073709547730LLU: // 99999999CR'''''''''''''''
65137+ case 18446744073709547721LLU: // 99999999CI'''''''''''''''
6492065138 {
6492165139 // variable u64 parnr_____ goes out of scope
6492265140 // emitted destructur for type u64
6492365141 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
64924- state.addr = 18446744073709547731LLU; // 99999999CS'''''''''''''''
65142+ state.addr = 18446744073709547722LLU; // 99999999CJ'''''''''''''''
6492565143 break;
6492665144 }
64927- case 18446744073709547731LLU: // 99999999CS'''''''''''''''
65145+ case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
6492865146 {
6492965147 // variable u64 mutable___ goes out of scope
6493065148 // emitted destructur for type u64
@@ -64937,7 +65155,7 @@
6493765155 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6493865156 }
6493965157 // ACCUMULATE ARGUMENTS - END
64940- uint64_t return_to = 18446744073709547728LLU;
65158+ uint64_t return_to = 18446744073709547719LLU;
6494165159 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6494265160 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6494365161 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64946,7 +65164,7 @@
6494665164 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6494765165 break;
6494865166 }
64949- case 18446744073709547728LLU: // 99999999CP'''''''''''''''
65167+ case 18446744073709547719LLU: // 99999999CG'''''''''''''''
6495065168 {
6495165169 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6495265170 // variable u64 INDIRECT__ goes out of scope
@@ -64957,18 +65175,18 @@
6495765175 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6495865176 heap.availilable_size_for_dynamic_objects += 0LLU;
6495965177 heap.availilable_size_for_dynamic_objects += 0LLU;
64960- state.addr = 18446744073709547727LLU; // 99999999CO'''''''''''''''
65178+ state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
6496165179 break;
6496265180 }
64963- case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
65181+ case 18446744073709547737LLU: // 99999999CY'''''''''''''''
6496465182 {
6496565183 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708110622720LLU;
6496665184
6496765185 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64968- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547726LLU : 18446744073709547725LLU;
65186+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547717LLU : 18446744073709547716LLU;
6496965187 break;
6497065188 }
64971- case 18446744073709547726LLU: // 99999999CN'''''''''''''''
65189+ case 18446744073709547717LLU: // 99999999CE'''''''''''''''
6497265190 {
6497365191 {
6497465192 uint64_t arg = 0LLU;
@@ -64990,10 +65208,10 @@
6499065208 };
6499165209 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6499265210 }
64993- state.addr = 18446744073709547724LLU; // 99999999CL'''''''''''''''
65211+ state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
6499465212 break;
6499565213 }
64996- case 18446744073709547724LLU: // 99999999CL'''''''''''''''
65214+ case 18446744073709547715LLU: // 99999999CC'''''''''''''''
6499765215 {
6499865216 // ACCUMULATE ARGUMENTS - BEGIN
6499965217 {
@@ -65001,7 +65219,7 @@
6500165219 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6500265220 }
6500365221 // ACCUMULATE ARGUMENTS - END
65004- uint64_t return_to = 18446744073709547722LLU;
65222+ uint64_t return_to = 18446744073709547713LLU;
6500565223 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6500665224 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6500765225 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65010,12 +65228,12 @@
6501065228 state.addr = 839519719621918720LLU; // skipws____
6501165229 break;
6501265230 }
65013- case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
65231+ case 18446744073709547713LLU: // 99999999CA'''''''''''''''
6501465232 {
65015- state.addr = 18446744073709547723LLU; // 99999999CK'''''''''''''''
65233+ state.addr = 18446744073709547714LLU; // 99999999CB'''''''''''''''
6501665234 break;
6501765235 }
65018- case 18446744073709547723LLU: // 99999999CK'''''''''''''''
65236+ case 18446744073709547714LLU: // 99999999CB'''''''''''''''
6501965237 {
6502065238 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6502165239 fprintf(stdout, "%s", "\n printid(stdout, ");
@@ -65029,7 +65247,7 @@
6502965247 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6503065248 }
6503165249 // ACCUMULATE ARGUMENTS - END
65032- uint64_t return_to = 18446744073709547719LLU;
65250+ uint64_t return_to = 18446744073709547710LLU;
6503365251 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6503465252 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6503565253 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65038,12 +65256,12 @@
6503865256 state.addr = 839519719621918720LLU; // skipws____
6503965257 break;
6504065258 }
65041- case 18446744073709547719LLU: // 99999999CG'''''''''''''''
65259+ case 18446744073709547710LLU: // 99999999B8'''''''''''''''
6504265260 {
65043- state.addr = 18446744073709547720LLU; // 99999999CH'''''''''''''''
65261+ state.addr = 18446744073709547711LLU; // 99999999B9'''''''''''''''
6504465262 break;
6504565263 }
65046- case 18446744073709547720LLU: // 99999999CH'''''''''''''''
65264+ case 18446744073709547711LLU: // 99999999B9'''''''''''''''
6504765265 {
6504865266 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6504965267 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65064,7 +65282,7 @@
6506465282 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6506565283 }
6506665284 // ACCUMULATE ARGUMENTS - END
65067- uint64_t return_to = 18446744073709547717LLU;
65285+ uint64_t return_to = 18446744073709547708LLU;
6506865286 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6506965287 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6507065288 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65073,12 +65291,12 @@
6507365291 state.addr = 517555565473470767LLU; // assertinit
6507465292 break;
6507565293 }
65076- case 18446744073709547717LLU: // 99999999CE'''''''''''''''
65294+ case 18446744073709547708LLU: // 99999999B6'''''''''''''''
6507765295 {
65078- state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
65296+ state.addr = 18446744073709547709LLU; // 99999999B7'''''''''''''''
6507965297 break;
6508065298 }
65081- case 18446744073709547718LLU: // 99999999CF'''''''''''''''
65299+ case 18446744073709547709LLU: // 99999999B7'''''''''''''''
6508265300 {
6508365301 {
6508465302 uint64_t arg = 0LLU;
@@ -65154,7 +65372,7 @@
6515465372 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6515565373 }
6515665374 // ACCUMULATE ARGUMENTS - END
65157- uint64_t return_to = 18446744073709547715LLU;
65375+ uint64_t return_to = 18446744073709547706LLU;
6515865376 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6515965377 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6516065378 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65163,12 +65381,12 @@
6516365381 state.addr = 787472342492567585LLU; // procvarref
6516465382 break;
6516565383 }
65166- case 18446744073709547715LLU: // 99999999CC'''''''''''''''
65384+ case 18446744073709547706LLU: // 99999999B4'''''''''''''''
6516765385 {
65168- state.addr = 18446744073709547716LLU; // 99999999CD'''''''''''''''
65386+ state.addr = 18446744073709547707LLU; // 99999999B5'''''''''''''''
6516965387 break;
6517065388 }
65171- case 18446744073709547716LLU: // 99999999CD'''''''''''''''
65389+ case 18446744073709547707LLU: // 99999999B5'''''''''''''''
6517265390 {
6517365391 // variable u64 initialize goes out of scope
6517465392 // emitted destructur for type u64
@@ -65179,10 +65397,10 @@
6517965397 // variable u64 idx_______ goes out of scope
6518065398 // emitted destructur for type u64
6518165399 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65182- state.addr = 18446744073709547721LLU; // 99999999CI'''''''''''''''
65400+ state.addr = 18446744073709547712LLU; // 99999999C_'''''''''''''''
6518365401 break;
6518465402 }
65185- case 18446744073709547721LLU: // 99999999CI'''''''''''''''
65403+ case 18446744073709547712LLU: // 99999999C_'''''''''''''''
6518665404 {
6518765405 fprintf(stdout, "%s", ");");
6518865406 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65191,7 +65409,7 @@
6519165409 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6519265410 }
6519365411 // ACCUMULATE ARGUMENTS - END
65194- uint64_t return_to = 18446744073709547713LLU;
65412+ uint64_t return_to = 18446744073709547704LLU;
6519565413 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6519665414 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6519765415 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65200,12 +65418,12 @@
6520065418 state.addr = 839519719621918720LLU; // skipws____
6520165419 break;
6520265420 }
65203- case 18446744073709547713LLU: // 99999999CA'''''''''''''''
65421+ case 18446744073709547704LLU: // 99999999B2'''''''''''''''
6520465422 {
65205- state.addr = 18446744073709547714LLU; // 99999999CB'''''''''''''''
65423+ state.addr = 18446744073709547705LLU; // 99999999B3'''''''''''''''
6520665424 break;
6520765425 }
65208- case 18446744073709547714LLU: // 99999999CB'''''''''''''''
65426+ case 18446744073709547705LLU: // 99999999B3'''''''''''''''
6520965427 {
6521065428 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6521165429 if(')' != (char)getchar())
@@ -65223,7 +65441,7 @@
6522365441 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6522465442 }
6522565443 // ACCUMULATE ARGUMENTS - END
65226- uint64_t return_to = 18446744073709547711LLU;
65444+ uint64_t return_to = 18446744073709547702LLU;
6522765445 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6522865446 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6522965447 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65232,12 +65450,12 @@
6523265450 state.addr = 517555565476695680LLU; // assertu64_
6523365451 break;
6523465452 }
65235- case 18446744073709547711LLU: // 99999999B9'''''''''''''''
65453+ case 18446744073709547702LLU: // 99999999B0'''''''''''''''
6523665454 {
65237- state.addr = 18446744073709547712LLU; // 99999999C_'''''''''''''''
65455+ state.addr = 18446744073709547703LLU; // 99999999B1'''''''''''''''
6523865456 break;
6523965457 }
65240- case 18446744073709547712LLU: // 99999999C_'''''''''''''''
65458+ case 18446744073709547703LLU: // 99999999B1'''''''''''''''
6524165459 {
6524265460 // variable u64 mutable___ goes out of scope
6524365461 // emitted destructur for type u64
@@ -65250,7 +65468,7 @@
6525065468 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6525165469 }
6525265470 // ACCUMULATE ARGUMENTS - END
65253- uint64_t return_to = 18446744073709547710LLU;
65471+ uint64_t return_to = 18446744073709547701LLU;
6525465472 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6525565473 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6525665474 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65259,7 +65477,7 @@
6525965477 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6526065478 break;
6526165479 }
65262- case 18446744073709547710LLU: // 99999999B8'''''''''''''''
65480+ case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
6526365481 {
6526465482 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6526565483 // variable u64 INDIRECT__ goes out of scope
@@ -65270,18 +65488,18 @@
6527065488 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6527165489 heap.availilable_size_for_dynamic_objects += 0LLU;
6527265490 heap.availilable_size_for_dynamic_objects += 0LLU;
65273- state.addr = 18446744073709547709LLU; // 99999999B7'''''''''''''''
65491+ state.addr = 18446744073709547700LLU; // 99999999By'''''''''''''''
6527465492 break;
6527565493 }
65276- case 18446744073709547725LLU: // 99999999CM'''''''''''''''
65494+ case 18446744073709547716LLU: // 99999999CD'''''''''''''''
6527765495 {
6527865496 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183515906048LLU;
6527965497
6528065498 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65281- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547708LLU : 18446744073709547707LLU;
65499+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547699LLU : 18446744073709547698LLU;
6528265500 break;
6528365501 }
65284- case 18446744073709547708LLU: // 99999999B6'''''''''''''''
65502+ case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
6528565503 {
6528665504 {
6528765505 uint64_t arg = 0LLU;
@@ -65303,10 +65521,10 @@
6530365521 };
6530465522 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6530565523 }
65306- state.addr = 18446744073709547706LLU; // 99999999B4'''''''''''''''
65524+ state.addr = 18446744073709547697LLU; // 99999999Bv'''''''''''''''
6530765525 break;
6530865526 }
65309- case 18446744073709547706LLU: // 99999999B4'''''''''''''''
65527+ case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
6531065528 {
6531165529 // ACCUMULATE ARGUMENTS - BEGIN
6531265530 {
@@ -65314,7 +65532,7 @@
6531465532 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6531565533 }
6531665534 // ACCUMULATE ARGUMENTS - END
65317- uint64_t return_to = 18446744073709547704LLU;
65535+ uint64_t return_to = 18446744073709547695LLU;
6531865536 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6531965537 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6532065538 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65323,12 +65541,12 @@
6532365541 state.addr = 839519719621918720LLU; // skipws____
6532465542 break;
6532565543 }
65326- case 18446744073709547704LLU: // 99999999B2'''''''''''''''
65544+ case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
6532765545 {
65328- state.addr = 18446744073709547705LLU; // 99999999B3'''''''''''''''
65546+ state.addr = 18446744073709547696LLU; // 99999999Bu'''''''''''''''
6532965547 break;
6533065548 }
65331- case 18446744073709547705LLU: // 99999999B3'''''''''''''''
65549+ case 18446744073709547696LLU: // 99999999Bu'''''''''''''''
6533265550 {
6533365551 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6533465552 fprintf(stdout, "%s", "\n printid(stderr, ");
@@ -65342,7 +65560,7 @@
6534265560 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6534365561 }
6534465562 // ACCUMULATE ARGUMENTS - END
65345- uint64_t return_to = 18446744073709547701LLU;
65563+ uint64_t return_to = 18446744073709547692LLU;
6534665564 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6534765565 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6534865566 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65351,12 +65569,12 @@
6535165569 state.addr = 839519719621918720LLU; // skipws____
6535265570 break;
6535365571 }
65354- case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
65572+ case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
6535565573 {
65356- state.addr = 18446744073709547702LLU; // 99999999B0'''''''''''''''
65574+ state.addr = 18446744073709547693LLU; // 99999999Br'''''''''''''''
6535765575 break;
6535865576 }
65359- case 18446744073709547702LLU: // 99999999B0'''''''''''''''
65577+ case 18446744073709547693LLU: // 99999999Br'''''''''''''''
6536065578 {
6536165579 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6536265580 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65377,7 +65595,7 @@
6537765595 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6537865596 }
6537965597 // ACCUMULATE ARGUMENTS - END
65380- uint64_t return_to = 18446744073709547699LLU;
65598+ uint64_t return_to = 18446744073709547690LLU;
6538165599 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6538265600 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6538365601 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65386,12 +65604,12 @@
6538665604 state.addr = 517555565473470767LLU; // assertinit
6538765605 break;
6538865606 }
65389- case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
65607+ case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
6539065608 {
65391- state.addr = 18446744073709547700LLU; // 99999999By'''''''''''''''
65609+ state.addr = 18446744073709547691LLU; // 99999999Bp'''''''''''''''
6539265610 break;
6539365611 }
65394- case 18446744073709547700LLU: // 99999999By'''''''''''''''
65612+ case 18446744073709547691LLU: // 99999999Bp'''''''''''''''
6539565613 {
6539665614 {
6539765615 uint64_t arg = 0LLU;
@@ -65467,7 +65685,7 @@
6546765685 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6546865686 }
6546965687 // ACCUMULATE ARGUMENTS - END
65470- uint64_t return_to = 18446744073709547697LLU;
65688+ uint64_t return_to = 18446744073709547688LLU;
6547165689 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6547265690 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6547365691 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65476,12 +65694,12 @@
6547665694 state.addr = 787472342492567585LLU; // procvarref
6547765695 break;
6547865696 }
65479- case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
65697+ case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
6548065698 {
65481- state.addr = 18446744073709547698LLU; // 99999999Bw'''''''''''''''
65699+ state.addr = 18446744073709547689LLU; // 99999999Bn'''''''''''''''
6548265700 break;
6548365701 }
65484- case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
65702+ case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
6548565703 {
6548665704 // variable u64 initialize goes out of scope
6548765705 // emitted destructur for type u64
@@ -65492,10 +65710,10 @@
6549265710 // variable u64 idx_______ goes out of scope
6549365711 // emitted destructur for type u64
6549465712 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65495- state.addr = 18446744073709547703LLU; // 99999999B1'''''''''''''''
65713+ state.addr = 18446744073709547694LLU; // 99999999Bs'''''''''''''''
6549665714 break;
6549765715 }
65498- case 18446744073709547703LLU: // 99999999B1'''''''''''''''
65716+ case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
6549965717 {
6550065718 fprintf(stdout, "%s", ");");
6550165719 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65504,7 +65722,7 @@
6550465722 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6550565723 }
6550665724 // ACCUMULATE ARGUMENTS - END
65507- uint64_t return_to = 18446744073709547695LLU;
65725+ uint64_t return_to = 18446744073709547686LLU;
6550865726 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6550965727 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6551065728 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65513,12 +65731,12 @@
6551365731 state.addr = 839519719621918720LLU; // skipws____
6551465732 break;
6551565733 }
65516- case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
65734+ case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
6551765735 {
65518- state.addr = 18446744073709547696LLU; // 99999999Bu'''''''''''''''
65736+ state.addr = 18446744073709547687LLU; // 99999999Bl'''''''''''''''
6551965737 break;
6552065738 }
65521- case 18446744073709547696LLU: // 99999999Bu'''''''''''''''
65739+ case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
6552265740 {
6552365741 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6552465742 if(')' != (char)getchar())
@@ -65536,7 +65754,7 @@
6553665754 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6553765755 }
6553865756 // ACCUMULATE ARGUMENTS - END
65539- uint64_t return_to = 18446744073709547693LLU;
65757+ uint64_t return_to = 18446744073709547684LLU;
6554065758 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6554165759 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6554265760 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65545,12 +65763,12 @@
6554565763 state.addr = 517555565476695680LLU; // assertu64_
6554665764 break;
6554765765 }
65548- case 18446744073709547693LLU: // 99999999Br'''''''''''''''
65766+ case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
6554965767 {
65550- state.addr = 18446744073709547694LLU; // 99999999Bs'''''''''''''''
65768+ state.addr = 18446744073709547685LLU; // 99999999Bj'''''''''''''''
6555165769 break;
6555265770 }
65553- case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
65771+ case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
6555465772 {
6555565773 // variable u64 mutable___ goes out of scope
6555665774 // emitted destructur for type u64
@@ -65563,7 +65781,7 @@
6556365781 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6556465782 }
6556565783 // ACCUMULATE ARGUMENTS - END
65566- uint64_t return_to = 18446744073709547692LLU;
65784+ uint64_t return_to = 18446744073709547683LLU;
6556765785 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6556865786 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6556965787 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65572,7 +65790,7 @@
6557265790 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6557365791 break;
6557465792 }
65575- case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
65793+ case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
6557665794 {
6557765795 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6557865796 // variable u64 INDIRECT__ goes out of scope
@@ -65583,18 +65801,18 @@
6558365801 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6558465802 heap.availilable_size_for_dynamic_objects += 0LLU;
6558565803 heap.availilable_size_for_dynamic_objects += 0LLU;
65586- state.addr = 18446744073709547691LLU; // 99999999Bp'''''''''''''''
65804+ state.addr = 18446744073709547682LLU; // 99999999Bg'''''''''''''''
6558765805 break;
6558865806 }
65589- case 18446744073709547707LLU: // 99999999B5'''''''''''''''
65807+ case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
6559065808 {
6559165809 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 660190761781821440LLU;
6559265810
6559365811 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65594- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547690LLU : 18446744073709547689LLU;
65812+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547681LLU : 18446744073709547680LLU;
6559565813 break;
6559665814 }
65597- case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
65815+ case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
6559865816 {
6559965817 {
6560065818 uint64_t arg = 0LLU;
@@ -65616,10 +65834,10 @@
6561665834 };
6561765835 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6561865836 }
65619- state.addr = 18446744073709547688LLU; // 99999999Bm'''''''''''''''
65837+ state.addr = 18446744073709547679LLU; // 99999999Bd'''''''''''''''
6562065838 break;
6562165839 }
65622- case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
65840+ case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
6562365841 {
6562465842 // ACCUMULATE ARGUMENTS - BEGIN
6562565843 {
@@ -65627,7 +65845,7 @@
6562765845 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6562865846 }
6562965847 // ACCUMULATE ARGUMENTS - END
65630- uint64_t return_to = 18446744073709547686LLU;
65848+ uint64_t return_to = 18446744073709547677LLU;
6563165849 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6563265850 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6563365851 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65636,12 +65854,12 @@
6563665854 state.addr = 839519719621918720LLU; // skipws____
6563765855 break;
6563865856 }
65639- case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
65857+ case 18446744073709547677LLU: // 99999999Bb'''''''''''''''
6564065858 {
65641- state.addr = 18446744073709547687LLU; // 99999999Bl'''''''''''''''
65859+ state.addr = 18446744073709547678LLU; // 99999999Bc'''''''''''''''
6564265860 break;
6564365861 }
65644- case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
65862+ case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
6564565863 {
6564665864 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6564765865 fprintf(stdout, "%s", "\n ++");
@@ -65655,7 +65873,7 @@
6565565873 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6565665874 }
6565765875 // ACCUMULATE ARGUMENTS - END
65658- uint64_t return_to = 18446744073709547683LLU;
65876+ uint64_t return_to = 18446744073709547674LLU;
6565965877 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6566065878 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6566165879 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65664,12 +65882,12 @@
6566465882 state.addr = 839519719621918720LLU; // skipws____
6566565883 break;
6566665884 }
65667- case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
65885+ case 18446744073709547674LLU: // 99999999BZ'''''''''''''''
6566865886 {
65669- state.addr = 18446744073709547684LLU; // 99999999Bi'''''''''''''''
65887+ state.addr = 18446744073709547675LLU; // 99999999B$'''''''''''''''
6567065888 break;
6567165889 }
65672- case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
65890+ case 18446744073709547675LLU: // 99999999B$'''''''''''''''
6567365891 {
6567465892 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6567565893 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65690,7 +65908,7 @@
6569065908 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6569165909 }
6569265910 // ACCUMULATE ARGUMENTS - END
65693- uint64_t return_to = 18446744073709547681LLU;
65911+ uint64_t return_to = 18446744073709547672LLU;
6569465912 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6569565913 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6569665914 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65699,12 +65917,12 @@
6569965917 state.addr = 517555565473470767LLU; // assertinit
6570065918 break;
6570165919 }
65702- case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
65920+ case 18446744073709547672LLU: // 99999999BX'''''''''''''''
6570365921 {
65704- state.addr = 18446744073709547682LLU; // 99999999Bg'''''''''''''''
65922+ state.addr = 18446744073709547673LLU; // 99999999BY'''''''''''''''
6570565923 break;
6570665924 }
65707- case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
65925+ case 18446744073709547673LLU: // 99999999BY'''''''''''''''
6570865926 {
6570965927 {
6571065928 uint64_t arg = 0LLU;
@@ -65780,7 +65998,7 @@
6578065998 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6578165999 }
6578266000 // ACCUMULATE ARGUMENTS - END
65783- uint64_t return_to = 18446744073709547679LLU;
66001+ uint64_t return_to = 18446744073709547670LLU;
6578466002 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6578566003 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6578666004 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65789,12 +66007,12 @@
6578966007 state.addr = 787472342492567585LLU; // procvarref
6579066008 break;
6579166009 }
65792- case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
66010+ case 18446744073709547670LLU: // 99999999BV'''''''''''''''
6579366011 {
65794- state.addr = 18446744073709547680LLU; // 99999999Be'''''''''''''''
66012+ state.addr = 18446744073709547671LLU; // 99999999BW'''''''''''''''
6579566013 break;
6579666014 }
65797- case 18446744073709547680LLU: // 99999999Be'''''''''''''''
66015+ case 18446744073709547671LLU: // 99999999BW'''''''''''''''
6579866016 {
6579966017 // variable u64 initialize goes out of scope
6580066018 // emitted destructur for type u64
@@ -65805,10 +66023,10 @@
6580566023 // variable u64 idx_______ goes out of scope
6580666024 // emitted destructur for type u64
6580766025 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65808- state.addr = 18446744073709547685LLU; // 99999999Bj'''''''''''''''
66026+ state.addr = 18446744073709547676LLU; // 99999999Ba'''''''''''''''
6580966027 break;
6581066028 }
65811- case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
66029+ case 18446744073709547676LLU: // 99999999Ba'''''''''''''''
6581266030 {
6581366031 fprintf(stdout, "%s", ";");
6581466032 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65817,7 +66035,7 @@
6581766035 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6581866036 }
6581966037 // ACCUMULATE ARGUMENTS - END
65820- uint64_t return_to = 18446744073709547677LLU;
66038+ uint64_t return_to = 18446744073709547668LLU;
6582166039 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6582266040 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6582366041 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65826,12 +66044,12 @@
6582666044 state.addr = 839519719621918720LLU; // skipws____
6582766045 break;
6582866046 }
65829- case 18446744073709547677LLU: // 99999999Bb'''''''''''''''
66047+ case 18446744073709547668LLU: // 99999999BT'''''''''''''''
6583066048 {
65831- state.addr = 18446744073709547678LLU; // 99999999Bc'''''''''''''''
66049+ state.addr = 18446744073709547669LLU; // 99999999BU'''''''''''''''
6583266050 break;
6583366051 }
65834- case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
66052+ case 18446744073709547669LLU: // 99999999BU'''''''''''''''
6583566053 {
6583666054 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6583766055 if(')' != (char)getchar())
@@ -65849,7 +66067,7 @@
6584966067 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6585066068 }
6585166069 // ACCUMULATE ARGUMENTS - END
65852- uint64_t return_to = 18446744073709547675LLU;
66070+ uint64_t return_to = 18446744073709547666LLU;
6585366071 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6585466072 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6585566073 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65858,12 +66076,12 @@
6585866076 state.addr = 517555565476695680LLU; // assertu64_
6585966077 break;
6586066078 }
65861- case 18446744073709547675LLU: // 99999999B$'''''''''''''''
66079+ case 18446744073709547666LLU: // 99999999BR'''''''''''''''
6586266080 {
65863- state.addr = 18446744073709547676LLU; // 99999999Ba'''''''''''''''
66081+ state.addr = 18446744073709547667LLU; // 99999999BS'''''''''''''''
6586466082 break;
6586566083 }
65866- case 18446744073709547676LLU: // 99999999Ba'''''''''''''''
66084+ case 18446744073709547667LLU: // 99999999BS'''''''''''''''
6586766085 {
6586866086 {
6586966087 uint64_t arg = 1LLU;
@@ -65891,7 +66109,7 @@
6589166109 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6589266110 }
6589366111 // ACCUMULATE ARGUMENTS - END
65894- uint64_t return_to = 18446744073709547672LLU;
66112+ uint64_t return_to = 18446744073709547663LLU;
6589566113 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6589666114 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6589766115 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65900,20 +66118,20 @@
6590066118 state.addr = 734295421765213120LLU; // mutassert_
6590166119 break;
6590266120 }
65903- case 18446744073709547672LLU: // 99999999BX'''''''''''''''
66121+ case 18446744073709547663LLU: // 99999999BO'''''''''''''''
6590466122 {
65905- state.addr = 18446744073709547673LLU; // 99999999BY'''''''''''''''
66123+ state.addr = 18446744073709547664LLU; // 99999999BP'''''''''''''''
6590666124 break;
6590766125 }
65908- case 18446744073709547673LLU: // 99999999BY'''''''''''''''
66126+ case 18446744073709547664LLU: // 99999999BP'''''''''''''''
6590966127 {
6591066128 // variable u64 parnr_____ goes out of scope
6591166129 // emitted destructur for type u64
6591266130 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
65913- state.addr = 18446744073709547674LLU; // 99999999BZ'''''''''''''''
66131+ state.addr = 18446744073709547665LLU; // 99999999BQ'''''''''''''''
6591466132 break;
6591566133 }
65916- case 18446744073709547674LLU: // 99999999BZ'''''''''''''''
66134+ case 18446744073709547665LLU: // 99999999BQ'''''''''''''''
6591766135 {
6591866136 // variable u64 mutable___ goes out of scope
6591966137 // emitted destructur for type u64
@@ -65926,7 +66144,7 @@
6592666144 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6592766145 }
6592866146 // ACCUMULATE ARGUMENTS - END
65929- uint64_t return_to = 18446744073709547671LLU;
66147+ uint64_t return_to = 18446744073709547662LLU;
6593066148 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6593166149 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6593266150 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65935,7 +66153,7 @@
6593566153 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6593666154 break;
6593766155 }
65938- case 18446744073709547671LLU: // 99999999BW'''''''''''''''
66156+ case 18446744073709547662LLU: // 99999999BN'''''''''''''''
6593966157 {
6594066158 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6594166159 // variable u64 INDIRECT__ goes out of scope
@@ -65946,18 +66164,18 @@
6594666164 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6594766165 heap.availilable_size_for_dynamic_objects += 0LLU;
6594866166 heap.availilable_size_for_dynamic_objects += 0LLU;
65949- state.addr = 18446744073709547670LLU; // 99999999BV'''''''''''''''
66167+ state.addr = 18446744073709547661LLU; // 99999999BM'''''''''''''''
6595066168 break;
6595166169 }
65952- case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
66170+ case 18446744073709547680LLU: // 99999999Be'''''''''''''''
6595366171 {
6595466172 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 567585494444015616LLU;
6595566173
6595666174 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65957- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547669LLU : 18446744073709547668LLU;
66175+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547660LLU : 18446744073709547659LLU;
6595866176 break;
6595966177 }
65960- case 18446744073709547669LLU: // 99999999BU'''''''''''''''
66178+ case 18446744073709547660LLU: // 99999999BL'''''''''''''''
6596166179 {
6596266180 {
6596366181 uint64_t arg = 0LLU;
@@ -65979,10 +66197,10 @@
6597966197 };
6598066198 *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = arg;
6598166199 }
65982- state.addr = 18446744073709547667LLU; // 99999999BS'''''''''''''''
66200+ state.addr = 18446744073709547658LLU; // 99999999BJ'''''''''''''''
6598366201 break;
6598466202 }
65985- case 18446744073709547667LLU: // 99999999BS'''''''''''''''
66203+ case 18446744073709547658LLU: // 99999999BJ'''''''''''''''
6598666204 {
6598766205 // ACCUMULATE ARGUMENTS - BEGIN
6598866206 {
@@ -65990,7 +66208,7 @@
6599066208 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6599166209 }
6599266210 // ACCUMULATE ARGUMENTS - END
65993- uint64_t return_to = 18446744073709547665LLU;
66211+ uint64_t return_to = 18446744073709547656LLU;
6599466212 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6599566213 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6599666214 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65999,12 +66217,12 @@
6599966217 state.addr = 839519719621918720LLU; // skipws____
6600066218 break;
6600166219 }
66002- case 18446744073709547665LLU: // 99999999BQ'''''''''''''''
66220+ case 18446744073709547656LLU: // 99999999BH'''''''''''''''
6600366221 {
66004- state.addr = 18446744073709547666LLU; // 99999999BR'''''''''''''''
66222+ state.addr = 18446744073709547657LLU; // 99999999BI'''''''''''''''
6600566223 break;
6600666224 }
66007- case 18446744073709547666LLU: // 99999999BR'''''''''''''''
66225+ case 18446744073709547657LLU: // 99999999BI'''''''''''''''
6600866226 {
6600966227 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6601066228 fprintf(stdout, "%s", "\n --");
@@ -66018,7 +66236,7 @@
6601866236 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6601966237 }
6602066238 // ACCUMULATE ARGUMENTS - END
66021- uint64_t return_to = 18446744073709547662LLU;
66239+ uint64_t return_to = 18446744073709547653LLU;
6602266240 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6602366241 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6602466242 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66027,12 +66245,12 @@
6602766245 state.addr = 839519719621918720LLU; // skipws____
6602866246 break;
6602966247 }
66030- case 18446744073709547662LLU: // 99999999BN'''''''''''''''
66248+ case 18446744073709547653LLU: // 99999999BE'''''''''''''''
6603166249 {
66032- state.addr = 18446744073709547663LLU; // 99999999BO'''''''''''''''
66250+ state.addr = 18446744073709547654LLU; // 99999999BF'''''''''''''''
6603366251 break;
6603466252 }
66035- case 18446744073709547663LLU: // 99999999BO'''''''''''''''
66253+ case 18446744073709547654LLU: // 99999999BF'''''''''''''''
6603666254 {
6603766255 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6603866256 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66053,7 +66271,7 @@
6605366271 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6605466272 }
6605566273 // ACCUMULATE ARGUMENTS - END
66056- uint64_t return_to = 18446744073709547660LLU;
66274+ uint64_t return_to = 18446744073709547651LLU;
6605766275 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6605866276 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6605966277 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66062,12 +66280,12 @@
6606266280 state.addr = 517555565473470767LLU; // assertinit
6606366281 break;
6606466282 }
66065- case 18446744073709547660LLU: // 99999999BL'''''''''''''''
66283+ case 18446744073709547651LLU: // 99999999BC'''''''''''''''
6606666284 {
66067- state.addr = 18446744073709547661LLU; // 99999999BM'''''''''''''''
66285+ state.addr = 18446744073709547652LLU; // 99999999BD'''''''''''''''
6606866286 break;
6606966287 }
66070- case 18446744073709547661LLU: // 99999999BM'''''''''''''''
66288+ case 18446744073709547652LLU: // 99999999BD'''''''''''''''
6607166289 {
6607266290 {
6607366291 uint64_t arg = 0LLU;
@@ -66143,7 +66361,7 @@
6614366361 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6614466362 }
6614566363 // ACCUMULATE ARGUMENTS - END
66146- uint64_t return_to = 18446744073709547658LLU;
66364+ uint64_t return_to = 18446744073709547649LLU;
6614766365 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6614866366 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6614966367 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66152,12 +66370,12 @@
6615266370 state.addr = 787472342492567585LLU; // procvarref
6615366371 break;
6615466372 }
66155- case 18446744073709547658LLU: // 99999999BJ'''''''''''''''
66373+ case 18446744073709547649LLU: // 99999999BA'''''''''''''''
6615666374 {
66157- state.addr = 18446744073709547659LLU; // 99999999BK'''''''''''''''
66375+ state.addr = 18446744073709547650LLU; // 99999999BB'''''''''''''''
6615866376 break;
6615966377 }
66160- case 18446744073709547659LLU: // 99999999BK'''''''''''''''
66378+ case 18446744073709547650LLU: // 99999999BB'''''''''''''''
6616166379 {
6616266380 // variable u64 initialize goes out of scope
6616366381 // emitted destructur for type u64
@@ -66168,10 +66386,10 @@
6616866386 // variable u64 idx_______ goes out of scope
6616966387 // emitted destructur for type u64
6617066388 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66171- state.addr = 18446744073709547664LLU; // 99999999BP'''''''''''''''
66389+ state.addr = 18446744073709547655LLU; // 99999999BG'''''''''''''''
6617266390 break;
6617366391 }
66174- case 18446744073709547664LLU: // 99999999BP'''''''''''''''
66392+ case 18446744073709547655LLU: // 99999999BG'''''''''''''''
6617566393 {
6617666394 fprintf(stdout, "%s", ";");
6617766395 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66180,7 +66398,7 @@
6618066398 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6618166399 }
6618266400 // ACCUMULATE ARGUMENTS - END
66183- uint64_t return_to = 18446744073709547656LLU;
66401+ uint64_t return_to = 18446744073709547647LLU;
6618466402 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6618566403 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6618666404 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66189,12 +66407,12 @@
6618966407 state.addr = 839519719621918720LLU; // skipws____
6619066408 break;
6619166409 }
66192- case 18446744073709547656LLU: // 99999999BH'''''''''''''''
66410+ case 18446744073709547647LLU: // 99999999A9'''''''''''''''
6619366411 {
66194- state.addr = 18446744073709547657LLU; // 99999999BI'''''''''''''''
66412+ state.addr = 18446744073709547648LLU; // 99999999B_'''''''''''''''
6619566413 break;
6619666414 }
66197- case 18446744073709547657LLU: // 99999999BI'''''''''''''''
66415+ case 18446744073709547648LLU: // 99999999B_'''''''''''''''
6619866416 {
6619966417 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6620066418 if(')' != (char)getchar())
@@ -66212,7 +66430,7 @@
6621266430 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6621366431 }
6621466432 // ACCUMULATE ARGUMENTS - END
66215- uint64_t return_to = 18446744073709547654LLU;
66433+ uint64_t return_to = 18446744073709547645LLU;
6621666434 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6621766435 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6621866436 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66221,12 +66439,12 @@
6622166439 state.addr = 517555565476695680LLU; // assertu64_
6622266440 break;
6622366441 }
66224- case 18446744073709547654LLU: // 99999999BF'''''''''''''''
66442+ case 18446744073709547645LLU: // 99999999A7'''''''''''''''
6622566443 {
66226- state.addr = 18446744073709547655LLU; // 99999999BG'''''''''''''''
66444+ state.addr = 18446744073709547646LLU; // 99999999A8'''''''''''''''
6622766445 break;
6622866446 }
66229- case 18446744073709547655LLU: // 99999999BG'''''''''''''''
66447+ case 18446744073709547646LLU: // 99999999A8'''''''''''''''
6623066448 {
6623166449 {
6623266450 uint64_t arg = 1LLU;
@@ -66254,7 +66472,7 @@
6625466472 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6625566473 }
6625666474 // ACCUMULATE ARGUMENTS - END
66257- uint64_t return_to = 18446744073709547651LLU;
66475+ uint64_t return_to = 18446744073709547642LLU;
6625866476 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6625966477 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6626066478 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66263,20 +66481,20 @@
6626366481 state.addr = 734295421765213120LLU; // mutassert_
6626466482 break;
6626566483 }
66266- case 18446744073709547651LLU: // 99999999BC'''''''''''''''
66484+ case 18446744073709547642LLU: // 99999999A4'''''''''''''''
6626766485 {
66268- state.addr = 18446744073709547652LLU; // 99999999BD'''''''''''''''
66486+ state.addr = 18446744073709547643LLU; // 99999999A5'''''''''''''''
6626966487 break;
6627066488 }
66271- case 18446744073709547652LLU: // 99999999BD'''''''''''''''
66489+ case 18446744073709547643LLU: // 99999999A5'''''''''''''''
6627266490 {
6627366491 // variable u64 parnr_____ goes out of scope
6627466492 // emitted destructur for type u64
6627566493 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
66276- state.addr = 18446744073709547653LLU; // 99999999BE'''''''''''''''
66494+ state.addr = 18446744073709547644LLU; // 99999999A6'''''''''''''''
6627766495 break;
6627866496 }
66279- case 18446744073709547653LLU: // 99999999BE'''''''''''''''
66497+ case 18446744073709547644LLU: // 99999999A6'''''''''''''''
6628066498 {
6628166499 // variable u64 mutable___ goes out of scope
6628266500 // emitted destructur for type u64
@@ -66289,7 +66507,7 @@
6628966507 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6629066508 }
6629166509 // ACCUMULATE ARGUMENTS - END
66292- uint64_t return_to = 18446744073709547650LLU;
66510+ uint64_t return_to = 18446744073709547641LLU;
6629366511 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6629466512 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6629566513 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66298,7 +66516,7 @@
6629866516 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6629966517 break;
6630066518 }
66301- case 18446744073709547650LLU: // 99999999BB'''''''''''''''
66519+ case 18446744073709547641LLU: // 99999999A3'''''''''''''''
6630266520 {
6630366521 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6630466522 // variable u64 INDIRECT__ goes out of scope
@@ -66309,50 +66527,50 @@
6630966527 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6631066528 heap.availilable_size_for_dynamic_objects += 0LLU;
6631166529 heap.availilable_size_for_dynamic_objects += 0LLU;
66312- state.addr = 18446744073709547649LLU; // 99999999BA'''''''''''''''
66530+ state.addr = 18446744073709547640LLU; // 99999999A2'''''''''''''''
6631366531 break;
6631466532 }
66315- case 18446744073709547668LLU: // 99999999BT'''''''''''''''
66533+ case 18446744073709547659LLU: // 99999999BK'''''''''''''''
6631666534 {
66317- state.addr = 18446744073709547649LLU; // 99999999BA'''''''''''''''
66535+ state.addr = 18446744073709547640LLU; // 99999999A2'''''''''''''''
6631866536 break;
6631966537 }
66320- case 18446744073709547649LLU: // 99999999BA'''''''''''''''
66538+ case 18446744073709547640LLU: // 99999999A2'''''''''''''''
6632166539 {
66322- state.addr = 18446744073709547670LLU; // 99999999BV'''''''''''''''
66540+ state.addr = 18446744073709547661LLU; // 99999999BM'''''''''''''''
6632366541 break;
6632466542 }
66325- case 18446744073709547670LLU: // 99999999BV'''''''''''''''
66543+ case 18446744073709547661LLU: // 99999999BM'''''''''''''''
6632666544 {
66327- state.addr = 18446744073709547691LLU; // 99999999Bp'''''''''''''''
66545+ state.addr = 18446744073709547682LLU; // 99999999Bg'''''''''''''''
6632866546 break;
6632966547 }
66330- case 18446744073709547691LLU: // 99999999Bp'''''''''''''''
66548+ case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
6633166549 {
66332- state.addr = 18446744073709547709LLU; // 99999999B7'''''''''''''''
66550+ state.addr = 18446744073709547700LLU; // 99999999By'''''''''''''''
6633366551 break;
6633466552 }
66335- case 18446744073709547709LLU: // 99999999B7'''''''''''''''
66553+ case 18446744073709547700LLU: // 99999999By'''''''''''''''
6633666554 {
66337- state.addr = 18446744073709547727LLU; // 99999999CO'''''''''''''''
66555+ state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
6633866556 break;
6633966557 }
66340- case 18446744073709547727LLU: // 99999999CO'''''''''''''''
66558+ case 18446744073709547718LLU: // 99999999CF'''''''''''''''
6634166559 {
66342- state.addr = 18446744073709547748LLU; // 99999999Ci'''''''''''''''
66560+ state.addr = 18446744073709547739LLU; // 99999999C$'''''''''''''''
6634366561 break;
6634466562 }
66345- case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
66563+ case 18446744073709547739LLU: // 99999999C$'''''''''''''''
6634666564 {
66347- state.addr = 18446744073709547769LLU; // 99999999C3'''''''''''''''
66565+ state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
6634866566 break;
6634966567 }
66350- case 18446744073709547769LLU: // 99999999C3'''''''''''''''
66568+ case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
6635166569 {
66352- state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
66570+ state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
6635366571 break;
6635466572 }
66355- case 18446744073709547787LLU: // 99999999DK'''''''''''''''
66573+ case 18446744073709547778LLU: // 99999999DB'''''''''''''''
6635666574 {
6635766575 // variable u64 sym_______ goes out of scope
6635866576 // emitted destructur for type u64
@@ -66402,10 +66620,10 @@
6640266620 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 532757408862961664LLU;
6640366621
6640466622 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66405- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547648LLU : 18446744073709547647LLU;
66623+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547639LLU : 18446744073709547638LLU;
6640666624 break;
6640766625 }
66408- case 18446744073709547648LLU: // 99999999B_'''''''''''''''
66626+ case 18446744073709547639LLU: // 99999999A1'''''''''''''''
6640966627 {
6641066628 {
6641166629 uint64_t arg = 0LLU;
@@ -66431,10 +66649,10 @@
6643166649 };
6643266650 *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = arg;
6643366651 }
66434- state.addr = 18446744073709547646LLU; // 99999999A8'''''''''''''''
66652+ state.addr = 18446744073709547637LLU; // 99999999Az'''''''''''''''
6643566653 break;
6643666654 }
66437- case 18446744073709547646LLU: // 99999999A8'''''''''''''''
66655+ case 18446744073709547637LLU: // 99999999Az'''''''''''''''
6643866656 {
6643966657 // ACCUMULATE ARGUMENTS - BEGIN
6644066658 {
@@ -66442,7 +66660,7 @@
6644266660 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6644366661 }
6644466662 // ACCUMULATE ARGUMENTS - END
66445- uint64_t return_to = 18446744073709547644LLU;
66663+ uint64_t return_to = 18446744073709547635LLU;
6644666664 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6644766665 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6644866666 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66451,12 +66669,12 @@
6645166669 state.addr = 839519719621918720LLU; // skipws____
6645266670 break;
6645366671 }
66454- case 18446744073709547644LLU: // 99999999A6'''''''''''''''
66672+ case 18446744073709547635LLU: // 99999999Ax'''''''''''''''
6645566673 {
66456- state.addr = 18446744073709547645LLU; // 99999999A7'''''''''''''''
66674+ state.addr = 18446744073709547636LLU; // 99999999Ay'''''''''''''''
6645766675 break;
6645866676 }
66459- case 18446744073709547645LLU: // 99999999A7'''''''''''''''
66677+ case 18446744073709547636LLU: // 99999999Ay'''''''''''''''
6646066678 {
6646166679 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6646266680 fprintf(stdout, "%s", "\n ");
@@ -66466,7 +66684,7 @@
6646666684 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6646766685 }
6646866686 // ACCUMULATE ARGUMENTS - END
66469- uint64_t return_to = 18446744073709547640LLU;
66687+ uint64_t return_to = 18446744073709547631LLU;
6647066688 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6647166689 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6647266690 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66475,12 +66693,12 @@
6647566693 state.addr = 839519719621918720LLU; // skipws____
6647666694 break;
6647766695 }
66478- case 18446744073709547640LLU: // 99999999A2'''''''''''''''
66696+ case 18446744073709547631LLU: // 99999999At'''''''''''''''
6647966697 {
66480- state.addr = 18446744073709547641LLU; // 99999999A3'''''''''''''''
66698+ state.addr = 18446744073709547632LLU; // 99999999Au'''''''''''''''
6648166699 break;
6648266700 }
66483- case 18446744073709547641LLU: // 99999999A3'''''''''''''''
66701+ case 18446744073709547632LLU: // 99999999Au'''''''''''''''
6648466702 {
6648566703 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6648666704 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66501,7 +66719,7 @@
6650166719 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6650266720 }
6650366721 // ACCUMULATE ARGUMENTS - END
66504- uint64_t return_to = 18446744073709547638LLU;
66722+ uint64_t return_to = 18446744073709547629LLU;
6650566723 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6650666724 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6650766725 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66510,12 +66728,12 @@
6651066728 state.addr = 517555565473470767LLU; // assertinit
6651166729 break;
6651266730 }
66513- case 18446744073709547638LLU: // 99999999A0'''''''''''''''
66731+ case 18446744073709547629LLU: // 99999999Ar'''''''''''''''
6651466732 {
66515- state.addr = 18446744073709547639LLU; // 99999999A1'''''''''''''''
66733+ state.addr = 18446744073709547630LLU; // 99999999As'''''''''''''''
6651666734 break;
6651766735 }
66518- case 18446744073709547639LLU: // 99999999A1'''''''''''''''
66736+ case 18446744073709547630LLU: // 99999999As'''''''''''''''
6651966737 {
6652066738 {
6652166739 uint64_t arg = 0LLU;
@@ -66591,7 +66809,7 @@
6659166809 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6659266810 }
6659366811 // ACCUMULATE ARGUMENTS - END
66594- uint64_t return_to = 18446744073709547636LLU;
66812+ uint64_t return_to = 18446744073709547627LLU;
6659566813 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6659666814 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6659766815 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66600,12 +66818,12 @@
6660066818 state.addr = 787472342492567585LLU; // procvarref
6660166819 break;
6660266820 }
66603- case 18446744073709547636LLU: // 99999999Ay'''''''''''''''
66821+ case 18446744073709547627LLU: // 99999999Ap'''''''''''''''
6660466822 {
66605- state.addr = 18446744073709547637LLU; // 99999999Az'''''''''''''''
66823+ state.addr = 18446744073709547628LLU; // 99999999Aq'''''''''''''''
6660666824 break;
6660766825 }
66608- case 18446744073709547637LLU: // 99999999Az'''''''''''''''
66826+ case 18446744073709547628LLU: // 99999999Aq'''''''''''''''
6660966827 {
6661066828 // variable u64 initialize goes out of scope
6661166829 // emitted destructur for type u64
@@ -66616,10 +66834,10 @@
6661666834 // variable u64 idx_______ goes out of scope
6661766835 // emitted destructur for type u64
6661866836 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66619- state.addr = 18446744073709547642LLU; // 99999999A4'''''''''''''''
66837+ state.addr = 18446744073709547633LLU; // 99999999Av'''''''''''''''
6662066838 break;
6662166839 }
66622- case 18446744073709547642LLU: // 99999999A4'''''''''''''''
66840+ case 18446744073709547633LLU: // 99999999Av'''''''''''''''
6662366841 {
6662466842 // ACCUMULATE ARGUMENTS - BEGIN
6662566843 {
@@ -66631,7 +66849,7 @@
6663166849 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6663266850 }
6663366851 // ACCUMULATE ARGUMENTS - END
66634- uint64_t return_to = 18446744073709547634LLU;
66852+ uint64_t return_to = 18446744073709547625LLU;
6663566853 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6663666854 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6663766855 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66640,12 +66858,12 @@
6664066858 state.addr = 517555565476695680LLU; // assertu64_
6664166859 break;
6664266860 }
66643- case 18446744073709547634LLU: // 99999999Aw'''''''''''''''
66861+ case 18446744073709547625LLU: // 99999999An'''''''''''''''
6664466862 {
66645- state.addr = 18446744073709547635LLU; // 99999999Ax'''''''''''''''
66863+ state.addr = 18446744073709547626LLU; // 99999999Ao'''''''''''''''
6664666864 break;
6664766865 }
66648- case 18446744073709547635LLU: // 99999999Ax'''''''''''''''
66866+ case 18446744073709547626LLU: // 99999999Ao'''''''''''''''
6664966867 {
6665066868 {
6665166869 uint64_t arg = 1LLU;
@@ -66673,7 +66891,7 @@
6667366891 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6667466892 }
6667566893 // ACCUMULATE ARGUMENTS - END
66676- uint64_t return_to = 18446744073709547631LLU;
66894+ uint64_t return_to = 18446744073709547622LLU;
6667766895 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6667866896 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6667966897 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66682,25 +66900,25 @@
6668266900 state.addr = 734295421765213120LLU; // mutassert_
6668366901 break;
6668466902 }
66685- case 18446744073709547631LLU: // 99999999At'''''''''''''''
66903+ case 18446744073709547622LLU: // 99999999Ak'''''''''''''''
6668666904 {
66687- state.addr = 18446744073709547632LLU; // 99999999Au'''''''''''''''
66905+ state.addr = 18446744073709547623LLU; // 99999999Al'''''''''''''''
6668866906 break;
6668966907 }
66690- case 18446744073709547632LLU: // 99999999Au'''''''''''''''
66908+ case 18446744073709547623LLU: // 99999999Al'''''''''''''''
6669166909 {
6669266910 // variable u64 parnr_____ goes out of scope
6669366911 // emitted destructur for type u64
6669466912 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
66695- state.addr = 18446744073709547633LLU; // 99999999Av'''''''''''''''
66913+ state.addr = 18446744073709547624LLU; // 99999999Am'''''''''''''''
6669666914 break;
6669766915 }
66698- case 18446744073709547633LLU: // 99999999Av'''''''''''''''
66916+ case 18446744073709547624LLU: // 99999999Am'''''''''''''''
6669966917 {
66700- state.addr = 18446744073709547643LLU; // 99999999A5'''''''''''''''
66918+ state.addr = 18446744073709547634LLU; // 99999999Aw'''''''''''''''
6670166919 break;
6670266920 }
66703- case 18446744073709547643LLU: // 99999999A5'''''''''''''''
66921+ case 18446744073709547634LLU: // 99999999Aw'''''''''''''''
6670466922 {
6670566923 // ACCUMULATE ARGUMENTS - BEGIN
6670666924 {
@@ -66708,7 +66926,7 @@
6670866926 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6670966927 }
6671066928 // ACCUMULATE ARGUMENTS - END
66711- uint64_t return_to = 18446744073709547629LLU;
66929+ uint64_t return_to = 18446744073709547620LLU;
6671266930 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6671366931 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6671466932 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66717,12 +66935,12 @@
6671766935 state.addr = 839519719621918720LLU; // skipws____
6671866936 break;
6671966937 }
66720- case 18446744073709547629LLU: // 99999999Ar'''''''''''''''
66938+ case 18446744073709547620LLU: // 99999999Ai'''''''''''''''
6672166939 {
66722- state.addr = 18446744073709547630LLU; // 99999999As'''''''''''''''
66940+ state.addr = 18446744073709547621LLU; // 99999999Aj'''''''''''''''
6672366941 break;
6672466942 }
66725- case 18446744073709547630LLU: // 99999999As'''''''''''''''
66943+ case 18446744073709547621LLU: // 99999999Aj'''''''''''''''
6672666944 {
6672766945 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6672866946 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66731,7 +66949,7 @@
6673166949 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6673266950 }
6673366951 // ACCUMULATE ARGUMENTS - END
66734- uint64_t return_to = 18446744073709547627LLU;
66952+ uint64_t return_to = 18446744073709547618LLU;
6673566953 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6673666954 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6673766955 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66740,12 +66958,12 @@
6674066958 state.addr = 839519719621918720LLU; // skipws____
6674166959 break;
6674266960 }
66743- case 18446744073709547627LLU: // 99999999Ap'''''''''''''''
66961+ case 18446744073709547618LLU: // 99999999Ag'''''''''''''''
6674466962 {
66745- state.addr = 18446744073709547628LLU; // 99999999Aq'''''''''''''''
66963+ state.addr = 18446744073709547619LLU; // 99999999Ah'''''''''''''''
6674666964 break;
6674766965 }
66748- case 18446744073709547628LLU: // 99999999Aq'''''''''''''''
66966+ case 18446744073709547619LLU: // 99999999Ah'''''''''''''''
6674966967 {
6675066968 fprintf(stdout, "%s", " = ~");
6675166969 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66754,7 +66972,7 @@
6675466972 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6675566973 }
6675666974 // ACCUMULATE ARGUMENTS - END
66757- uint64_t return_to = 18446744073709547623LLU;
66975+ uint64_t return_to = 18446744073709547614LLU;
6675866976 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6675966977 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6676066978 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66763,12 +66981,12 @@
6676366981 state.addr = 839519719621918720LLU; // skipws____
6676466982 break;
6676566983 }
66766- case 18446744073709547623LLU: // 99999999Al'''''''''''''''
66984+ case 18446744073709547614LLU: // 99999999Ac'''''''''''''''
6676766985 {
66768- state.addr = 18446744073709547624LLU; // 99999999Am'''''''''''''''
66986+ state.addr = 18446744073709547615LLU; // 99999999Ad'''''''''''''''
6676966987 break;
6677066988 }
66771- case 18446744073709547624LLU: // 99999999Am'''''''''''''''
66989+ case 18446744073709547615LLU: // 99999999Ad'''''''''''''''
6677266990 {
6677366991 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6677466992 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66789,7 +67007,7 @@
6678967007 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6679067008 }
6679167009 // ACCUMULATE ARGUMENTS - END
66792- uint64_t return_to = 18446744073709547621LLU;
67010+ uint64_t return_to = 18446744073709547612LLU;
6679367011 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6679467012 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6679567013 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66798,12 +67016,12 @@
6679867016 state.addr = 517555565473470767LLU; // assertinit
6679967017 break;
6680067018 }
66801- case 18446744073709547621LLU: // 99999999Aj'''''''''''''''
67019+ case 18446744073709547612LLU: // 99999999Aa'''''''''''''''
6680267020 {
66803- state.addr = 18446744073709547622LLU; // 99999999Ak'''''''''''''''
67021+ state.addr = 18446744073709547613LLU; // 99999999Ab'''''''''''''''
6680467022 break;
6680567023 }
66806- case 18446744073709547622LLU: // 99999999Ak'''''''''''''''
67024+ case 18446744073709547613LLU: // 99999999Ab'''''''''''''''
6680767025 {
6680867026 {
6680967027 uint64_t arg = 0LLU;
@@ -66879,7 +67097,7 @@
6687967097 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6688067098 }
6688167099 // ACCUMULATE ARGUMENTS - END
66882- uint64_t return_to = 18446744073709547619LLU;
67100+ uint64_t return_to = 18446744073709547610LLU;
6688367101 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6688467102 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6688567103 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66888,12 +67106,12 @@
6688867106 state.addr = 787472342492567585LLU; // procvarref
6688967107 break;
6689067108 }
66891- case 18446744073709547619LLU: // 99999999Ah'''''''''''''''
67109+ case 18446744073709547610LLU: // 99999999AZ'''''''''''''''
6689267110 {
66893- state.addr = 18446744073709547620LLU; // 99999999Ai'''''''''''''''
67111+ state.addr = 18446744073709547611LLU; // 99999999A$'''''''''''''''
6689467112 break;
6689567113 }
66896- case 18446744073709547620LLU: // 99999999Ai'''''''''''''''
67114+ case 18446744073709547611LLU: // 99999999A$'''''''''''''''
6689767115 {
6689867116 // variable u64 initialize goes out of scope
6689967117 // emitted destructur for type u64
@@ -66904,10 +67122,10 @@
6690467122 // variable u64 idx_______ goes out of scope
6690567123 // emitted destructur for type u64
6690667124 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66907- state.addr = 18446744073709547625LLU; // 99999999An'''''''''''''''
67125+ state.addr = 18446744073709547616LLU; // 99999999Ae'''''''''''''''
6690867126 break;
6690967127 }
66910- case 18446744073709547625LLU: // 99999999An'''''''''''''''
67128+ case 18446744073709547616LLU: // 99999999Ae'''''''''''''''
6691167129 {
6691267130 // ACCUMULATE ARGUMENTS - BEGIN
6691367131 {
@@ -66919,7 +67137,7 @@
6691967137 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6692067138 }
6692167139 // ACCUMULATE ARGUMENTS - END
66922- uint64_t return_to = 18446744073709547617LLU;
67140+ uint64_t return_to = 18446744073709547608LLU;
6692367141 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6692467142 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6692567143 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66928,17 +67146,17 @@
6692867146 state.addr = 517555565476695680LLU; // assertu64_
6692967147 break;
6693067148 }
66931- case 18446744073709547617LLU: // 99999999Af'''''''''''''''
67149+ case 18446744073709547608LLU: // 99999999AX'''''''''''''''
6693267150 {
66933- state.addr = 18446744073709547618LLU; // 99999999Ag'''''''''''''''
67151+ state.addr = 18446744073709547609LLU; // 99999999AY'''''''''''''''
6693467152 break;
6693567153 }
66936- case 18446744073709547618LLU: // 99999999Ag'''''''''''''''
67154+ case 18446744073709547609LLU: // 99999999AY'''''''''''''''
6693767155 {
66938- state.addr = 18446744073709547626LLU; // 99999999Ao'''''''''''''''
67156+ state.addr = 18446744073709547617LLU; // 99999999Af'''''''''''''''
6693967157 break;
6694067158 }
66941- case 18446744073709547626LLU: // 99999999Ao'''''''''''''''
67159+ case 18446744073709547617LLU: // 99999999Af'''''''''''''''
6694267160 {
6694367161 // ACCUMULATE ARGUMENTS - BEGIN
6694467162 {
@@ -66946,7 +67164,7 @@
6694667164 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6694767165 }
6694867166 // ACCUMULATE ARGUMENTS - END
66949- uint64_t return_to = 18446744073709547615LLU;
67167+ uint64_t return_to = 18446744073709547606LLU;
6695067168 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6695167169 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6695267170 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66955,12 +67173,12 @@
6695567173 state.addr = 839519719621918720LLU; // skipws____
6695667174 break;
6695767175 }
66958- case 18446744073709547615LLU: // 99999999Ad'''''''''''''''
67176+ case 18446744073709547606LLU: // 99999999AV'''''''''''''''
6695967177 {
66960- state.addr = 18446744073709547616LLU; // 99999999Ae'''''''''''''''
67178+ state.addr = 18446744073709547607LLU; // 99999999AW'''''''''''''''
6696167179 break;
6696267180 }
66963- case 18446744073709547616LLU: // 99999999Ae'''''''''''''''
67181+ case 18446744073709547607LLU: // 99999999AW'''''''''''''''
6696467182 {
6696567183 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6696667184 if(')' != (char)getchar())
@@ -66977,7 +67195,7 @@
6697767195 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6697867196 }
6697967197 // ACCUMULATE ARGUMENTS - END
66980- uint64_t return_to = 18446744073709547614LLU;
67198+ uint64_t return_to = 18446744073709547605LLU;
6698167199 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6698267200 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6698367201 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66986,7 +67204,7 @@
6698667204 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6698767205 break;
6698867206 }
66989- case 18446744073709547614LLU: // 99999999Ac'''''''''''''''
67207+ case 18446744073709547605LLU: // 99999999AU'''''''''''''''
6699067208 {
6699167209 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 19
6699267210 // variable u64 mutable___ goes out of scope
@@ -67000,18 +67218,18 @@
6700067218 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6700167219 heap.availilable_size_for_dynamic_objects += 0LLU;
6700267220 heap.availilable_size_for_dynamic_objects += 0LLU;
67003- state.addr = 18446744073709547613LLU; // 99999999Ab'''''''''''''''
67221+ state.addr = 18446744073709547604LLU; // 99999999AT'''''''''''''''
6700467222 break;
6700567223 }
67006- case 18446744073709547647LLU: // 99999999A9'''''''''''''''
67224+ case 18446744073709547638LLU: // 99999999A0'''''''''''''''
6700767225 {
6700867226 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 750618996096630784LLU;
6700967227
6701067228 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
67011- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547612LLU : 18446744073709547611LLU;
67229+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547603LLU : 18446744073709547602LLU;
6701267230 break;
6701367231 }
67014- case 18446744073709547612LLU: // 99999999Aa'''''''''''''''
67232+ case 18446744073709547603LLU: // 99999999AS'''''''''''''''
6701567233 {
6701667234 {
6701767235 uint64_t arg = 0LLU;
@@ -67037,10 +67255,10 @@
6703767255 };
6703867256 *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = arg;
6703967257 }
67040- state.addr = 18446744073709547610LLU; // 99999999AZ'''''''''''''''
67258+ state.addr = 18446744073709547601LLU; // 99999999AQ'''''''''''''''
6704167259 break;
6704267260 }
67043- case 18446744073709547610LLU: // 99999999AZ'''''''''''''''
67261+ case 18446744073709547601LLU: // 99999999AQ'''''''''''''''
6704467262 {
6704567263 // ACCUMULATE ARGUMENTS - BEGIN
6704667264 {
@@ -67048,7 +67266,7 @@
6704867266 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6704967267 }
6705067268 // ACCUMULATE ARGUMENTS - END
67051- uint64_t return_to = 18446744073709547608LLU;
67269+ uint64_t return_to = 18446744073709547599LLU;
6705267270 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6705367271 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6705467272 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67057,12 +67275,12 @@
6705767275 state.addr = 839519719621918720LLU; // skipws____
6705867276 break;
6705967277 }
67060- case 18446744073709547608LLU: // 99999999AX'''''''''''''''
67278+ case 18446744073709547599LLU: // 99999999AO'''''''''''''''
6706167279 {
67062- state.addr = 18446744073709547609LLU; // 99999999AY'''''''''''''''
67280+ state.addr = 18446744073709547600LLU; // 99999999AP'''''''''''''''
6706367281 break;
6706467282 }
67065- case 18446744073709547609LLU: // 99999999AY'''''''''''''''
67283+ case 18446744073709547600LLU: // 99999999AP'''''''''''''''
6706667284 {
6706767285 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6706867286 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67071,7 +67289,7 @@
6707167289 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6707267290 }
6707367291 // ACCUMULATE ARGUMENTS - END
67074- uint64_t return_to = 18446744073709547606LLU;
67292+ uint64_t return_to = 18446744073709547597LLU;
6707567293 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6707667294 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6707767295 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67080,12 +67298,12 @@
6708067298 state.addr = 839519719621918720LLU; // skipws____
6708167299 break;
6708267300 }
67083- case 18446744073709547606LLU: // 99999999AV'''''''''''''''
67301+ case 18446744073709547597LLU: // 99999999AM'''''''''''''''
6708467302 {
67085- state.addr = 18446744073709547607LLU; // 99999999AW'''''''''''''''
67303+ state.addr = 18446744073709547598LLU; // 99999999AN'''''''''''''''
6708667304 break;
6708767305 }
67088- case 18446744073709547607LLU: // 99999999AW'''''''''''''''
67306+ case 18446744073709547598LLU: // 99999999AN'''''''''''''''
6708967307 {
6709067308 fprintf(stdout, "%s", "\n ");
6709167309 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67094,7 +67312,7 @@
6709467312 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6709567313 }
6709667314 // ACCUMULATE ARGUMENTS - END
67097- uint64_t return_to = 18446744073709547602LLU;
67315+ uint64_t return_to = 18446744073709547593LLU;
6709867316 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6709967317 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6710067318 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67103,12 +67321,12 @@
6710367321 state.addr = 839519719621918720LLU; // skipws____
6710467322 break;
6710567323 }
67106- case 18446744073709547602LLU: // 99999999AR'''''''''''''''
67324+ case 18446744073709547593LLU: // 99999999AI'''''''''''''''
6710767325 {
67108- state.addr = 18446744073709547603LLU; // 99999999AS'''''''''''''''
67326+ state.addr = 18446744073709547594LLU; // 99999999AJ'''''''''''''''
6710967327 break;
6711067328 }
67111- case 18446744073709547603LLU: // 99999999AS'''''''''''''''
67329+ case 18446744073709547594LLU: // 99999999AJ'''''''''''''''
6711267330 {
6711367331 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6711467332 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67129,7 +67347,7 @@
6712967347 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6713067348 }
6713167349 // ACCUMULATE ARGUMENTS - END
67132- uint64_t return_to = 18446744073709547600LLU;
67350+ uint64_t return_to = 18446744073709547591LLU;
6713367351 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6713467352 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6713567353 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67138,12 +67356,12 @@
6713867356 state.addr = 517555565473470767LLU; // assertinit
6713967357 break;
6714067358 }
67141- case 18446744073709547600LLU: // 99999999AP'''''''''''''''
67359+ case 18446744073709547591LLU: // 99999999AG'''''''''''''''
6714267360 {
67143- state.addr = 18446744073709547601LLU; // 99999999AQ'''''''''''''''
67361+ state.addr = 18446744073709547592LLU; // 99999999AH'''''''''''''''
6714467362 break;
6714567363 }
67146- case 18446744073709547601LLU: // 99999999AQ'''''''''''''''
67364+ case 18446744073709547592LLU: // 99999999AH'''''''''''''''
6714767365 {
6714867366 {
6714967367 uint64_t arg = 0LLU;
@@ -67219,7 +67437,7 @@
6721967437 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6722067438 }
6722167439 // ACCUMULATE ARGUMENTS - END
67222- uint64_t return_to = 18446744073709547598LLU;
67440+ uint64_t return_to = 18446744073709547589LLU;
6722367441 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6722467442 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6722567443 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67228,12 +67446,12 @@
6722867446 state.addr = 787472342492567585LLU; // procvarref
6722967447 break;
6723067448 }
67231- case 18446744073709547598LLU: // 99999999AN'''''''''''''''
67449+ case 18446744073709547589LLU: // 99999999AE'''''''''''''''
6723267450 {
67233- state.addr = 18446744073709547599LLU; // 99999999AO'''''''''''''''
67451+ state.addr = 18446744073709547590LLU; // 99999999AF'''''''''''''''
6723467452 break;
6723567453 }
67236- case 18446744073709547599LLU: // 99999999AO'''''''''''''''
67454+ case 18446744073709547590LLU: // 99999999AF'''''''''''''''
6723767455 {
6723867456 // variable u64 initialize goes out of scope
6723967457 // emitted destructur for type u64
@@ -67244,10 +67462,10 @@
6724467462 // variable u64 idx_______ goes out of scope
6724567463 // emitted destructur for type u64
6724667464 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
67247- state.addr = 18446744073709547604LLU; // 99999999AT'''''''''''''''
67465+ state.addr = 18446744073709547595LLU; // 99999999AK'''''''''''''''
6724867466 break;
6724967467 }
67250- case 18446744073709547604LLU: // 99999999AT'''''''''''''''
67468+ case 18446744073709547595LLU: // 99999999AK'''''''''''''''
6725167469 {
6725267470 // ACCUMULATE ARGUMENTS - BEGIN
6725367471 {
@@ -67259,7 +67477,7 @@
6725967477 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6726067478 }
6726167479 // ACCUMULATE ARGUMENTS - END
67262- uint64_t return_to = 18446744073709547596LLU;
67480+ uint64_t return_to = 18446744073709547587LLU;
6726367481 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6726467482 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6726567483 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67268,12 +67486,12 @@
6726867486 state.addr = 517555565476695680LLU; // assertu64_
6726967487 break;
6727067488 }
67271- case 18446744073709547596LLU: // 99999999AL'''''''''''''''
67489+ case 18446744073709547587LLU: // 99999999AC'''''''''''''''
6727267490 {
67273- state.addr = 18446744073709547597LLU; // 99999999AM'''''''''''''''
67491+ state.addr = 18446744073709547588LLU; // 99999999AD'''''''''''''''
6727467492 break;
6727567493 }
67276- case 18446744073709547597LLU: // 99999999AM'''''''''''''''
67494+ case 18446744073709547588LLU: // 99999999AD'''''''''''''''
6727767495 {
6727867496 {
6727967497 uint64_t arg = 1LLU;
@@ -67301,7 +67519,7 @@
6730167519 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6730267520 }
6730367521 // ACCUMULATE ARGUMENTS - END
67304- uint64_t return_to = 18446744073709547593LLU;
67522+ uint64_t return_to = 18446744073709547584LLU;
6730567523 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6730667524 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6730767525 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67310,25 +67528,25 @@
6731067528 state.addr = 734295421765213120LLU; // mutassert_
6731167529 break;
6731267530 }
67313- case 18446744073709547593LLU: // 99999999AI'''''''''''''''
67531+ case 18446744073709547584LLU: // 99999999A_'''''''''''''''
6731467532 {
67315- state.addr = 18446744073709547594LLU; // 99999999AJ'''''''''''''''
67533+ state.addr = 18446744073709547585LLU; // 99999999AA'''''''''''''''
6731667534 break;
6731767535 }
67318- case 18446744073709547594LLU: // 99999999AJ'''''''''''''''
67536+ case 18446744073709547585LLU: // 99999999AA'''''''''''''''
6731967537 {
6732067538 // variable u64 parnr_____ goes out of scope
6732167539 // emitted destructur for type u64
6732267540 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
67323- state.addr = 18446744073709547595LLU; // 99999999AK'''''''''''''''
67541+ state.addr = 18446744073709547586LLU; // 99999999AB'''''''''''''''
6732467542 break;
6732567543 }
67326- case 18446744073709547595LLU: // 99999999AK'''''''''''''''
67544+ case 18446744073709547586LLU: // 99999999AB'''''''''''''''
6732767545 {
67328- state.addr = 18446744073709547605LLU; // 99999999AU'''''''''''''''
67546+ state.addr = 18446744073709547596LLU; // 99999999AL'''''''''''''''
6732967547 break;
6733067548 }
67331- case 18446744073709547605LLU: // 99999999AU'''''''''''''''
67549+ case 18446744073709547596LLU: // 99999999AL'''''''''''''''
6733267550 {
6733367551 // ACCUMULATE ARGUMENTS - BEGIN
6733467552 {
@@ -67336,7 +67554,7 @@
6733667554 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6733767555 }
6733867556 // ACCUMULATE ARGUMENTS - END
67339- uint64_t return_to = 18446744073709547591LLU;
67557+ uint64_t return_to = 18446744073709547582LLU;
6734067558 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6734167559 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6734267560 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67345,12 +67563,12 @@
6734567563 state.addr = 839519719621918720LLU; // skipws____
6734667564 break;
6734767565 }
67348- case 18446744073709547591LLU: // 99999999AG'''''''''''''''
67566+ case 18446744073709547582LLU: // 99999999_8'''''''''''''''
6734967567 {
67350- state.addr = 18446744073709547592LLU; // 99999999AH'''''''''''''''
67568+ state.addr = 18446744073709547583LLU; // 99999999_9'''''''''''''''
6735167569 break;
6735267570 }
67353- case 18446744073709547592LLU: // 99999999AH'''''''''''''''
67571+ case 18446744073709547583LLU: // 99999999_9'''''''''''''''
6735467572 {
6735567573 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6735667574 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67359,7 +67577,7 @@
6735967577 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6736067578 }
6736167579 // ACCUMULATE ARGUMENTS - END
67362- uint64_t return_to = 18446744073709547589LLU;
67580+ uint64_t return_to = 18446744073709547580LLU;
6736367581 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6736467582 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6736567583 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67368,12 +67586,12 @@
6736867586 state.addr = 839519719621918720LLU; // skipws____
6736967587 break;
6737067588 }
67371- case 18446744073709547589LLU: // 99999999AE'''''''''''''''
67589+ case 18446744073709547580LLU: // 99999999_6'''''''''''''''
6737267590 {
67373- state.addr = 18446744073709547590LLU; // 99999999AF'''''''''''''''
67591+ state.addr = 18446744073709547581LLU; // 99999999_7'''''''''''''''
6737467592 break;
6737567593 }
67376- case 18446744073709547590LLU: // 99999999AF'''''''''''''''
67594+ case 18446744073709547581LLU: // 99999999_7'''''''''''''''
6737767595 {
6737867596 fprintf(stdout, "%s", " = !");
6737967597 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67382,7 +67600,7 @@
6738267600 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6738367601 }
6738467602 // ACCUMULATE ARGUMENTS - END
67385- uint64_t return_to = 18446744073709547585LLU;
67603+ uint64_t return_to = 18446744073709547576LLU;
6738667604 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6738767605 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6738867606 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67391,12 +67609,12 @@
6739167609 state.addr = 839519719621918720LLU; // skipws____
6739267610 break;
6739367611 }
67394- case 18446744073709547585LLU: // 99999999AA'''''''''''''''
67612+ case 18446744073709547576LLU: // 99999999_2'''''''''''''''
6739567613 {
67396- state.addr = 18446744073709547586LLU; // 99999999AB'''''''''''''''
67614+ state.addr = 18446744073709547577LLU; // 99999999_3'''''''''''''''
6739767615 break;
6739867616 }
67399- case 18446744073709547586LLU: // 99999999AB'''''''''''''''
67617+ case 18446744073709547577LLU: // 99999999_3'''''''''''''''
6740067618 {
6740167619 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6740267620 // ACCUMULATE ARGUMENTS - BEGIN
@@ -67417,7 +67635,7 @@
6741767635 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6741867636 }
6741967637 // ACCUMULATE ARGUMENTS - END
67420- uint64_t return_to = 18446744073709547583LLU;
67638+ uint64_t return_to = 18446744073709547574LLU;
6742167639 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6742267640 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6742367641 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67426,12 +67644,12 @@
6742667644 state.addr = 517555565473470767LLU; // assertinit
6742767645 break;
6742867646 }
67429- case 18446744073709547583LLU: // 99999999_9'''''''''''''''
67647+ case 18446744073709547574LLU: // 99999999_0'''''''''''''''
6743067648 {
67431- state.addr = 18446744073709547584LLU; // 99999999A_'''''''''''''''
67649+ state.addr = 18446744073709547575LLU; // 99999999_1'''''''''''''''
6743267650 break;
6743367651 }
67434- case 18446744073709547584LLU: // 99999999A_'''''''''''''''
67652+ case 18446744073709547575LLU: // 99999999_1'''''''''''''''
6743567653 {
6743667654 {
6743767655 uint64_t arg = 0LLU;
@@ -67507,7 +67725,7 @@
6750767725 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6750867726 }
6750967727 // ACCUMULATE ARGUMENTS - END
67510- uint64_t return_to = 18446744073709547581LLU;
67728+ uint64_t return_to = 18446744073709547572LLU;
6751167729 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6751267730 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6751367731 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67516,12 +67734,12 @@
6751667734 state.addr = 787472342492567585LLU; // procvarref
6751767735 break;
6751867736 }
67519- case 18446744073709547581LLU: // 99999999_7'''''''''''''''
67737+ case 18446744073709547572LLU: // 99999999_y'''''''''''''''
6752067738 {
67521- state.addr = 18446744073709547582LLU; // 99999999_8'''''''''''''''
67739+ state.addr = 18446744073709547573LLU; // 99999999_z'''''''''''''''
6752267740 break;
6752367741 }
67524- case 18446744073709547582LLU: // 99999999_8'''''''''''''''
67742+ case 18446744073709547573LLU: // 99999999_z'''''''''''''''
6752567743 {
6752667744 // variable u64 initialize goes out of scope
6752767745 // emitted destructur for type u64
@@ -67532,10 +67750,10 @@
6753267750 // variable u64 idx_______ goes out of scope
6753367751 // emitted destructur for type u64
6753467752 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
67535- state.addr = 18446744073709547587LLU; // 99999999AC'''''''''''''''
67753+ state.addr = 18446744073709547578LLU; // 99999999_4'''''''''''''''
6753667754 break;
6753767755 }
67538- case 18446744073709547587LLU: // 99999999AC'''''''''''''''
67756+ case 18446744073709547578LLU: // 99999999_4'''''''''''''''
6753967757 {
6754067758 // ACCUMULATE ARGUMENTS - BEGIN
6754167759 {
@@ -67547,7 +67765,7 @@
6754767765 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6754867766 }
6754967767 // ACCUMULATE ARGUMENTS - END
67550- uint64_t return_to = 18446744073709547579LLU;
67768+ uint64_t return_to = 18446744073709547570LLU;
6755167769 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6755267770 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6755367771 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67556,17 +67774,17 @@
6755667774 state.addr = 517555565476695680LLU; // assertu64_
6755767775 break;
6755867776 }
67559- case 18446744073709547579LLU: // 99999999_5'''''''''''''''
67777+ case 18446744073709547570LLU: // 99999999_w'''''''''''''''
6756067778 {
67561- state.addr = 18446744073709547580LLU; // 99999999_6'''''''''''''''
67779+ state.addr = 18446744073709547571LLU; // 99999999_x'''''''''''''''
6756267780 break;
6756367781 }
67564- case 18446744073709547580LLU: // 99999999_6'''''''''''''''
67782+ case 18446744073709547571LLU: // 99999999_x'''''''''''''''
6756567783 {
67566- state.addr = 18446744073709547588LLU; // 99999999AD'''''''''''''''
67784+ state.addr = 18446744073709547579LLU; // 99999999_5'''''''''''''''
6756767785 break;
6756867786 }
67569- case 18446744073709547588LLU: // 99999999AD'''''''''''''''
67787+ case 18446744073709547579LLU: // 99999999_5'''''''''''''''
6757067788 {
6757167789 // ACCUMULATE ARGUMENTS - BEGIN
6757267790 {
@@ -67574,7 +67792,7 @@
6757467792 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6757567793 }
6757667794 // ACCUMULATE ARGUMENTS - END
67577- uint64_t return_to = 18446744073709547577LLU;
67795+ uint64_t return_to = 18446744073709547568LLU;
6757867796 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6757967797 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6758067798 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67583,12 +67801,12 @@
6758367801 state.addr = 839519719621918720LLU; // skipws____
6758467802 break;
6758567803 }
67586- case 18446744073709547577LLU: // 99999999_3'''''''''''''''
67804+ case 18446744073709547568LLU: // 99999999_u'''''''''''''''
6758767805 {
67588- state.addr = 18446744073709547578LLU; // 99999999_4'''''''''''''''
67806+ state.addr = 18446744073709547569LLU; // 99999999_v'''''''''''''''
6758967807 break;
6759067808 }
67591- case 18446744073709547578LLU: // 99999999_4'''''''''''''''
67809+ case 18446744073709547569LLU: // 99999999_v'''''''''''''''
6759267810 {
6759367811 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6759467812 if(')' != (char)getchar())
@@ -67605,7 +67823,7 @@
6760567823 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6760667824 }
6760767825 // ACCUMULATE ARGUMENTS - END
67608- uint64_t return_to = 18446744073709547576LLU;
67826+ uint64_t return_to = 18446744073709547567LLU;
6760967827 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6761067828 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6761167829 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67614,7 +67832,7 @@
6761467832 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
6761567833 break;
6761667834 }
67617- case 18446744073709547576LLU: // 99999999_2'''''''''''''''
67835+ case 18446744073709547567LLU: // 99999999_t'''''''''''''''
6761867836 {
6761967837 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 19
6762067838 // variable u64 mutable___ goes out of scope
@@ -67628,18 +67846,18 @@
6762867846 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6762967847 heap.availilable_size_for_dynamic_objects += 0LLU;
6763067848 heap.availilable_size_for_dynamic_objects += 0LLU;
67631- state.addr = 18446744073709547575LLU; // 99999999_1'''''''''''''''
67849+ state.addr = 18446744073709547566LLU; // 99999999_s'''''''''''''''
6763267850 break;
6763367851 }
67634- case 18446744073709547611LLU: // 99999999A$'''''''''''''''
67852+ case 18446744073709547602LLU: // 99999999AR'''''''''''''''
6763567853 {
6763667854 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 782701543416397824LLU;
6763767855
6763867856 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
67639- state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547574LLU : 18446744073709547573LLU;
67857+ state.addr = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547565LLU : 18446744073709547564LLU;
6764067858 break;
6764167859 }
67642- case 18446744073709547574LLU: // 99999999_0'''''''''''''''
67860+ case 18446744073709547565LLU: // 99999999_r'''''''''''''''
6764367861 {
6764467862 {
6764567863 uint64_t arg = 0LLU;
@@ -67665,10 +67883,10 @@
6766567883 };
6766667884 *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = arg;
6766767885 }
67668- state.addr = 18446744073709547572LLU; // 99999999_y'''''''''''''''
67886+ state.addr = 18446744073709547563LLU; // 99999999_p'''''''''''''''
6766967887 break;
6767067888 }
67671- case 18446744073709547572LLU: // 99999999_y'''''''''''''''
67889+ case 18446744073709547563LLU: // 99999999_p'''''''''''''''
6767267890 {
6767367891 // ACCUMULATE ARGUMENTS - BEGIN
6767467892 {
@@ -67676,7 +67894,7 @@
6767667894 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6767767895 }
6767867896 // ACCUMULATE ARGUMENTS - END
67679- uint64_t return_to = 18446744073709547570LLU;
67897+ uint64_t return_to = 18446744073709547561LLU;
6768067898 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6768167899 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6768267900 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67685,12 +67903,12 @@
6768567903 state.addr = 839519719621918720LLU; // skipws____
6768667904 break;
6768767905 }
67688- case 18446744073709547570LLU: // 99999999_w'''''''''''''''
67906+ case 18446744073709547561LLU: // 99999999_n'''''''''''''''
6768967907 {
67690- state.addr = 18446744073709547571LLU; // 99999999_x'''''''''''''''
67908+ state.addr = 18446744073709547562LLU; // 99999999_o'''''''''''''''
6769167909 break;
6769267910 }
67693- case 18446744073709547571LLU: // 99999999_x'''''''''''''''
67911+ case 18446744073709547562LLU: // 99999999_o'''''''''''''''
6769467912 {
6769567913 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6769667914 fprintf(stdout, "%s", "\n ");
@@ -67700,7 +67918,7 @@
6770067918 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6770167919 }
6770267920 // ACCUMULATE ARGUMENTS - END
67703- uint64_t return_to = 18446744073709547566LLU;
67921+ uint64_t return_to = 18446744073709547557LLU;
6770467922 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6770567923 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6770667924 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -67709,12 +67927,12 @@
6770967927 state.addr = 839519719621918720LLU; // skipws____
6771067928