• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision923 (tree)
Time2020-02-12 05:08:28
Authorjakobthomsen

Log Message

reorder

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 922)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 923)
@@ -44106,779 +44106,6 @@
4410644106 }
4410744107 break;
4410844108 }
44109- case 787472338265246569LLU: // procreturn
44110- {
44111- state.addr = /*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 10LLU)) ? 18446744073709549030LLU : 18446744073709549029LLU;
44112- break;
44113- }
44114- case 18446744073709549030LLU: // 99999999Wk'''''''''''''''
44115- {
44116- {
44117- uint64_t arg = 1LLU;
44118- LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44119- }
44120- {
44121- uint64_t arg = /*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU));
44122- LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44123- }
44124- {
44125- uint64_t arg = 0;
44126- LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44127- }
44128- state.addr = 18446744073709549028LLU; // 99999999Wi'''''''''''''''
44129- break;
44130- }
44131- case 18446744073709549028LLU: // 99999999Wi'''''''''''''''
44132- {
44133- if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU))
44134- {
44135- (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
44136- (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
44137- {
44138- state.addr = 18446744073709549027LLU; // 99999999Wh'''''''''''''''
44139- break;
44140- }
44141- }
44142- /*direct*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = (*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) << 1) + 1LLU;
44143- *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) = heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)].elem0;
44144- // ACCUMULATE ARGUMENTS - BEGIN
44145- {
44146- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 19LLU, 11LLU);
44147- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44148- }
44149- // ACCUMULATE ARGUMENTS - END
44150- uint64_t return_to = 18446744073709549025LLU;
44151- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44152- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44153- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44154- heap.data[0].elem1 = heap.data[0].elem0;
44155- heap.data[0].elem0 = restore;
44156- state.addr = 839519719621918720LLU; // skipws____
44157- break;
44158- }
44159- case 18446744073709549025LLU: // 99999999Wf'''''''''''''''
44160- {
44161- state.addr = 18446744073709549026LLU; // 99999999Wg'''''''''''''''
44162- break;
44163- }
44164- case 18446744073709549026LLU: // 99999999Wg'''''''''''''''
44165- {
44166- state.addr = /*first_____*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709549024LLU : 18446744073709549023LLU;
44167- break;
44168- }
44169- case 18446744073709549024LLU: // 99999999We'''''''''''''''
44170- {
44171- matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
44172- *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) = 0LLU;
44173-
44174- heap.availilable_size_for_dynamic_objects += 0LLU;
44175- heap.availilable_size_for_dynamic_objects += 0LLU;
44176- state.addr = 18446744073709549022LLU; // 99999999Wc'''''''''''''''
44177- break;
44178- }
44179- case 18446744073709549023LLU: // 99999999Wd'''''''''''''''
44180- {
44181- matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
44182- state.addr = 18446744073709549022LLU; // 99999999Wc'''''''''''''''
44183- break;
44184- }
44185- case 18446744073709549022LLU: // 99999999Wc'''''''''''''''
44186- {
44187- fprintf(stdout, "%s", "\n swap(&");
44188- {
44189- uint64_t arg = 0;
44190- LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44191- }
44192- {
44193- uint64_t arg = 0;;
44194- {
44195- uint64_t constridx = 0LLU; // typeu64___
44196- arg = pair_move(&heap, &constridx, &arg);
44197- };
44198- *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = arg;
44199- }
44200- state.addr = 18446744073709549020LLU; // 99999999Wa'''''''''''''''
44201- break;
44202- }
44203- case 18446744073709549020LLU: // 99999999Wa'''''''''''''''
44204- {
44205- {
44206- uint64_t arg = 0LLU;
44207- LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44208- }
44209- {
44210- uint64_t arg = 0LLU;
44211- LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44212- }
44213- {
44214- uint64_t arg = 0LLU;
44215- LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44216- }
44217- {
44218- uint64_t arg = 0LLU;
44219- LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44220- }
44221- {
44222- uint64_t arg = 0LLU;
44223- LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44224- }
44225- // ACCUMULATE ARGUMENTS - BEGIN
44226- {
44227- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 25LLU, 11LLU);
44228- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44229- }
44230- // ACCUMULATE ARGUMENTS - END
44231- uint64_t return_to = 18446744073709549017LLU;
44232- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44233- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44234- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44235- heap.data[0].elem1 = heap.data[0].elem0;
44236- heap.data[0].elem0 = restore;
44237- state.addr = 839519719621918720LLU; // skipws____
44238- break;
44239- }
44240- case 18446744073709549017LLU: // 99999999WY'''''''''''''''
44241- {
44242- state.addr = 18446744073709549018LLU; // 99999999WZ'''''''''''''''
44243- break;
44244- }
44245- case 18446744073709549018LLU: // 99999999WZ'''''''''''''''
44246- {
44247- /*id1_______*/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 11LLU)));
44248- // ACCUMULATE ARGUMENTS - BEGIN
44249- {
44250- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 25LLU, 11LLU);
44251- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44252- }
44253- // ACCUMULATE ARGUMENTS - END
44254- uint64_t return_to = 18446744073709549015LLU;
44255- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44256- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44257- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44258- heap.data[0].elem1 = heap.data[0].elem0;
44259- heap.data[0].elem0 = restore;
44260- state.addr = 839519719621918720LLU; // skipws____
44261- break;
44262- }
44263- case 18446744073709549015LLU: // 99999999WW'''''''''''''''
44264- {
44265- state.addr = 18446744073709549016LLU; // 99999999WX'''''''''''''''
44266- break;
44267- }
44268- case 18446744073709549016LLU: // 99999999WX'''''''''''''''
44269- {
44270- {
44271- uint64_t arg = 40LLU;
44272- LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44273- }
44274- {
44275- uint64_t arg = 0LLU;
44276- LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44277- }
44278- /*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));
44279- state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709549014LLU : 18446744073709549013LLU;
44280- break;
44281- }
44282- case 18446744073709549014LLU: // 99999999WV'''''''''''''''
44283- {
44284- // ACCUMULATE ARGUMENTS - BEGIN
44285- {
44286- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
44287- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44288- }
44289- // ACCUMULATE ARGUMENTS - END
44290- uint64_t return_to = 18446744073709549011LLU;
44291- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44292- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44293- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44294- heap.data[0].elem1 = heap.data[0].elem0;
44295- heap.data[0].elem0 = restore;
44296- state.addr = 819847183515949359LLU; // reportinit
44297- break;
44298- }
44299- case 18446744073709549011LLU: // 99999999WS'''''''''''''''
44300- {
44301- state.addr = 18446744073709549012LLU; // 99999999WT'''''''''''''''
44302- break;
44303- }
44304- case 18446744073709549012LLU: // 99999999WT'''''''''''''''
44305- {
44306- {
44307- fprintf(stderr, "%s\n", "return from call not implemented");
44308- exit(-1);
44309- }
44310- heap.availilable_size_for_dynamic_objects += 0LLU;
44311- heap.availilable_size_for_dynamic_objects += 0LLU;
44312- state.addr = 18446744073709549010LLU; // 99999999WR'''''''''''''''
44313- break;
44314- }
44315- case 18446744073709549013LLU: // 99999999WU'''''''''''''''
44316- {
44317- {
44318- uint64_t arg = 0LLU;
44319- LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44320- }
44321- // ACCUMULATE ARGUMENTS - BEGIN
44322- {
44323- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
44324- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44325- }
44326- {
44327- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU);
44328- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44329- }
44330- {
44331- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
44332- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44333- }
44334- {
44335- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
44336- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44337- }
44338- {
44339- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
44340- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44341- }
44342- {
44343- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
44344- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44345- }
44346- {
44347- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 28LLU, 11LLU);
44348- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44349- }
44350- {
44351- uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
44352- LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44353- }
44354- {
44355- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU);
44356- LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44357- }
44358- {
44359- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU);
44360- LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44361- }
44362- {
44363- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 24LLU);
44364- LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44365- }
44366- {
44367- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
44368- LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44369- }
44370- {
44371- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU);
44372- LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44373- }
44374- {
44375- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU);
44376- LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44377- }
44378- {
44379- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU);
44380- LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44381- }
44382- // ACCUMULATE ARGUMENTS - END
44383- uint64_t return_to = 18446744073709549008LLU;
44384- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
44385- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44386- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44387- heap.data[0].elem1 = heap.data[0].elem0;
44388- heap.data[0].elem0 = restore;
44389- state.addr = 787472342492567585LLU; // procvarref
44390- break;
44391- }
44392- case 18446744073709549008LLU: // 99999999WP'''''''''''''''
44393- {
44394- state.addr = 18446744073709549009LLU; // 99999999WQ'''''''''''''''
44395- break;
44396- }
44397- case 18446744073709549009LLU: // 99999999WQ'''''''''''''''
44398- {
44399- // variable u64 idx_______ goes out of scope
44400- // emitted destructur for type u64
44401- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 28
44402- state.addr = 18446744073709549010LLU; // 99999999WR'''''''''''''''
44403- break;
44404- }
44405- case 18446744073709549010LLU: // 99999999WR'''''''''''''''
44406- {
44407- // ACCUMULATE ARGUMENTS - BEGIN
44408- {
44409- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
44410- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44411- }
44412- {
44413- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 20LLU);
44414- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44415- }
44416- {
44417- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 22LLU);
44418- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44419- }
44420- {
44421- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU);
44422- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44423- }
44424- {
44425- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU);
44426- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44427- }
44428- // ACCUMULATE ARGUMENTS - END
44429- uint64_t return_to = 18446744073709549006LLU;
44430- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
44431- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44432- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44433- heap.data[0].elem1 = heap.data[0].elem0;
44434- heap.data[0].elem0 = restore;
44435- state.addr = 842862227159939072LLU; // swappable_
44436- break;
44437- }
44438- case 18446744073709549006LLU: // 99999999WN'''''''''''''''
44439- {
44440- state.addr = 18446744073709549007LLU; // 99999999WO'''''''''''''''
44441- break;
44442- }
44443- case 18446744073709549007LLU: // 99999999WO'''''''''''''''
44444- {
44445- {
44446- uint64_t arg = 819865187908583424LLU;
44447- LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44448- }
44449- // ACCUMULATE ARGUMENTS - BEGIN
44450- {
44451- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
44452- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44453- }
44454- {
44455- uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
44456- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44457- }
44458- {
44459- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
44460- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44461- }
44462- {
44463- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
44464- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44465- }
44466- // ACCUMULATE ARGUMENTS - END
44467- uint64_t return_to = 18446744073709549004LLU;
44468- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
44469- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44470- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44471- heap.data[0].elem1 = heap.data[0].elem0;
44472- heap.data[0].elem0 = restore;
44473- state.addr = 660220410725010287LLU; // initassert
44474- break;
44475- }
44476- case 18446744073709549004LLU: // 99999999WL'''''''''''''''
44477- {
44478- state.addr = 18446744073709549005LLU; // 99999999WM'''''''''''''''
44479- break;
44480- }
44481- case 18446744073709549005LLU: // 99999999WM'''''''''''''''
44482- {
44483- // ACCUMULATE ARGUMENTS - BEGIN
44484- {
44485- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
44486- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44487- }
44488- {
44489- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
44490- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44491- }
44492- {
44493- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
44494- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44495- }
44496- {
44497- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
44498- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44499- }
44500- // ACCUMULATE ARGUMENTS - END
44501- uint64_t return_to = 18446744073709549002LLU;
44502- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
44503- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44504- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44505- heap.data[0].elem1 = heap.data[0].elem0;
44506- heap.data[0].elem0 = restore;
44507- state.addr = 732615645798520865LLU; // movevarref
44508- break;
44509- }
44510- case 18446744073709549002LLU: // 99999999WJ'''''''''''''''
44511- {
44512- state.addr = 18446744073709549003LLU; // 99999999WK'''''''''''''''
44513- break;
44514- }
44515- case 18446744073709549003LLU: // 99999999WK'''''''''''''''
44516- {
44517- // variable u64 info______ goes out of scope
44518- // emitted destructur for type u64
44519- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 28
44520- // variable u64 called____ goes out of scope
44521- // emitted destructur for type u64
44522- (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 27
44523- // variable u64 sym_______ goes out of scope
44524- // emitted destructur for type u64
44525- (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 26
44526- state.addr = 18446744073709549019LLU; // 99999999W$'''''''''''''''
44527- break;
44528- }
44529- case 18446744073709549019LLU: // 99999999W$'''''''''''''''
44530- {
44531- // ACCUMULATE ARGUMENTS - BEGIN
44532- {
44533- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 25LLU, 0LLU);
44534- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44535- }
44536- {
44537- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 25LLU, 18LLU), 0LLU);
44538- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44539- }
44540- {
44541- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 25LLU, 19LLU);
44542- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44543- }
44544- // ACCUMULATE ARGUMENTS - END
44545- uint64_t return_to = 18446744073709549000LLU;
44546- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
44547- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44548- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44549- heap.data[0].elem1 = heap.data[0].elem0;
44550- heap.data[0].elem0 = restore;
44551- state.addr = 861504774606556015LLU; // typeassert
44552- break;
44553- }
44554- case 18446744073709549000LLU: // 99999999WH'''''''''''''''
44555- {
44556- state.addr = 18446744073709549001LLU; // 99999999WI'''''''''''''''
44557- break;
44558- }
44559- case 18446744073709549001LLU: // 99999999WI'''''''''''''''
44560- {
44561- // variable u64 parameter_ goes out of scope
44562- // emitted destructur for type u64
44563- (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 25
44564- // variable u64 mutable___ goes out of scope
44565- // emitted destructur for type u64
44566- (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 24
44567- // variable u64 INDIRECT__ goes out of scope
44568- // emitted destructur for type u64
44569- (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 23
44570- // variable u64 init1_____ goes out of scope
44571- // emitted destructur for type u64
44572- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 22
44573- // variable u64 id1_______ goes out of scope
44574- // emitted destructur for type u64
44575- (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 21
44576- // variable type______ typesrc___ goes out of scope
44577- // emitted destructur for type type______
44578- // ACCUMULATE ARGUMENTS - BEGIN
44579- {
44580- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
44581- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44582- }
44583- // ACCUMULATE ARGUMENTS - END
44584- uint64_t return_to = 18446744073709548999LLU;
44585- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44586- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44587- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44588- heap.data[0].elem1 = heap.data[0].elem0;
44589- heap.data[0].elem0 = restore;
44590- state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
44591- break;
44592- }
44593- case 18446744073709548999LLU: // 99999999WG'''''''''''''''
44594- {
44595- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 20
44596- state.addr = 18446744073709549021LLU; // 99999999Wb'''''''''''''''
44597- break;
44598- }
44599- case 18446744073709549021LLU: // 99999999Wb'''''''''''''''
44600- {
44601- fprintf(stdout, "%s", ", &");
44602- // ACCUMULATE ARGUMENTS - BEGIN
44603- {
44604- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 19LLU, 12LLU);
44605- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44606- }
44607- {
44608- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 19LLU, 13LLU);
44609- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44610- }
44611- {
44612- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU);
44613- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44614- }
44615- {
44616- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 19LLU, 18LLU), 1LLU);
44617- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44618- }
44619- {
44620- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 19LLU, 18LLU), 2LLU);
44621- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44622- }
44623- // ACCUMULATE ARGUMENTS - END
44624- uint64_t return_to = 18446744073709548997LLU;
44625- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
44626- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44627- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44628- heap.data[0].elem1 = heap.data[0].elem0;
44629- heap.data[0].elem0 = restore;
44630- state.addr = 587881357514113024LLU; // emitpar___
44631- break;
44632- }
44633- case 18446744073709548997LLU: // 99999999WE'''''''''''''''
44634- {
44635- state.addr = 18446744073709548998LLU; // 99999999WF'''''''''''''''
44636- break;
44637- }
44638- case 18446744073709548998LLU: // 99999999WF'''''''''''''''
44639- {
44640- fprintf(stdout, "%s", "); // result");
44641- // parameter-reference resdest___ respar____ goes out of scope
44642- // parameter-reference list<resdest___> results___ goes out of scope
44643- state.addr = 18446744073709549028LLU; // 99999999Wi'''''''''''''''
44644- break;
44645- }
44646- case 18446744073709549027LLU: // 99999999Wh'''''''''''''''
44647- {
44648- // ACCUMULATE ARGUMENTS - BEGIN
44649- {
44650- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 17LLU, 11LLU);
44651- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44652- }
44653- // ACCUMULATE ARGUMENTS - END
44654- uint64_t return_to = 18446744073709548995LLU;
44655- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44656- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44657- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44658- heap.data[0].elem1 = heap.data[0].elem0;
44659- heap.data[0].elem0 = restore;
44660- state.addr = 839519719621918720LLU; // skipws____
44661- break;
44662- }
44663- case 18446744073709548995LLU: // 99999999WC'''''''''''''''
44664- {
44665- state.addr = 18446744073709548996LLU; // 99999999WD'''''''''''''''
44666- break;
44667- }
44668- case 18446744073709548996LLU: // 99999999WD'''''''''''''''
44669- {
44670- matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)));
44671- // variable u64 first_____ goes out of scope
44672- // emitted destructur for type u64
44673- (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 17
44674- heap.availilable_size_for_dynamic_objects += 0LLU;
44675- heap.availilable_size_for_dynamic_objects += 0LLU;
44676- state.addr = 18446744073709548994LLU; // 99999999WB'''''''''''''''
44677- break;
44678- }
44679- case 18446744073709549029LLU: // 99999999Wj'''''''''''''''
44680- {
44681- // ACCUMULATE ARGUMENTS - BEGIN
44682- {
44683- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
44684- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44685- }
44686- // ACCUMULATE ARGUMENTS - END
44687- uint64_t return_to = 18446744073709548992LLU;
44688- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44689- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44690- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44691- heap.data[0].elem1 = heap.data[0].elem0;
44692- heap.data[0].elem0 = restore;
44693- state.addr = 839519719621918720LLU; // skipws____
44694- break;
44695- }
44696- case 18446744073709548992LLU: // 99999999W_'''''''''''''''
44697- {
44698- state.addr = 18446744073709548993LLU; // 99999999WA'''''''''''''''
44699- break;
44700- }
44701- case 18446744073709548993LLU: // 99999999WA'''''''''''''''
44702- {
44703- {
44704- uint64_t arg = 40LLU;
44705- LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44706- }
44707- {
44708- uint64_t arg = 0LLU;
44709- LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
44710- }
44711- /*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));
44712- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548991LLU : 18446744073709548990LLU;
44713- break;
44714- }
44715- case 18446744073709548991LLU: // 99999999V9'''''''''''''''
44716- {
44717- matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
44718- // ACCUMULATE ARGUMENTS - BEGIN
44719- {
44720- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU);
44721- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44722- }
44723- // ACCUMULATE ARGUMENTS - END
44724- uint64_t return_to = 18446744073709548988LLU;
44725- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44726- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44727- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44728- heap.data[0].elem1 = heap.data[0].elem0;
44729- heap.data[0].elem0 = restore;
44730- state.addr = 839519719621918720LLU; // skipws____
44731- break;
44732- }
44733- case 18446744073709548988LLU: // 99999999V6'''''''''''''''
44734- {
44735- state.addr = 18446744073709548989LLU; // 99999999V7'''''''''''''''
44736- break;
44737- }
44738- case 18446744073709548989LLU: // 99999999V7'''''''''''''''
44739- {
44740- matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
44741- state.addr = 18446744073709548990LLU; // 99999999V8'''''''''''''''
44742- break;
44743- }
44744- case 18446744073709548990LLU: // 99999999V8'''''''''''''''
44745- {
44746- // variable u64 matchsym__ goes out of scope
44747- // emitted destructur for type u64
44748- (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference matchsym__ at 18
44749- // variable u64 sym_______ goes out of scope
44750- // emitted destructur for type u64
44751- (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 17
44752- state.addr = 18446744073709548994LLU; // 99999999WB'''''''''''''''
44753- break;
44754- }
44755- case 18446744073709548994LLU: // 99999999WB'''''''''''''''
44756- {
44757- // ACCUMULATE ARGUMENTS - BEGIN
44758- {
44759- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
44760- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44761- }
44762- // ACCUMULATE ARGUMENTS - END
44763- uint64_t return_to = 18446744073709548986LLU;
44764- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
44765- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44766- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44767- heap.data[0].elem1 = heap.data[0].elem0;
44768- heap.data[0].elem0 = restore;
44769- state.addr = 839519719621918720LLU; // skipws____
44770- break;
44771- }
44772- case 18446744073709548986LLU: // 99999999V4'''''''''''''''
44773- {
44774- state.addr = 18446744073709548987LLU; // 99999999V5'''''''''''''''
44775- break;
44776- }
44777- case 18446744073709548987LLU: // 99999999V5'''''''''''''''
44778- {
44779- matchid("}", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 11LLU)));
44780- // ACCUMULATE ARGUMENTS - BEGIN
44781- {
44782- uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 16LLU, 1LLU);
44783- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44784- }
44785- {
44786- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 16LLU, 7LLU);
44787- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44788- }
44789- {
44790- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 16LLU, 0LLU);
44791- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44792- }
44793- {
44794- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
44795- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44796- }
44797- {
44798- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 16LLU, 8LLU);
44799- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44800- }
44801- {
44802- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 16LLU, 12LLU);
44803- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44804- }
44805- {
44806- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 16LLU, 13LLU);
44807- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44808- }
44809- {
44810- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU);
44811- LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44812- }
44813- {
44814- uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
44815- LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44816- }
44817- {
44818- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 16LLU, 9LLU);
44819- LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44820- }
44821- {
44822- uint64_t arg = /*results___*/*LOCAL_ACCESS(heap.data, 16LLU, 10LLU);
44823- LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
44824- }
44825- // ACCUMULATE ARGUMENTS - END
44826- uint64_t return_to = 18446744073709548984LLU;
44827- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
44828- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
44829- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
44830- heap.data[0].elem1 = heap.data[0].elem0;
44831- heap.data[0].elem0 = restore;
44832- state.addr = 533581901720365984LLU; // blockclose
44833- break;
44834- }
44835- case 18446744073709548984LLU: // 99999999V2'''''''''''''''
44836- {
44837- state.addr = 18446744073709548985LLU; // 99999999V3'''''''''''''''
44838- break;
44839- }
44840- case 18446744073709548985LLU: // 99999999V3'''''''''''''''
44841- {
44842- // parameter-reference u64 remainheap goes out of scope
44843- (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainheap at 16
44844- // parameter-reference u64 remainsize goes out of scope
44845- (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainsize at 15
44846- // parameter-reference u64 defbodysz_ goes out of scope
44847- (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defbodysz_ at 14
44848- // parameter-reference u64 defargcnt_ goes out of scope
44849- (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defargcnt_ at 13
44850- // parameter-reference u64 c_________ goes out of scope
44851- (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 12
44852- // parameter-reference list<resdest___> results___ goes out of scope
44853- (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 11
44854- // parameter-reference list<varentry__> varlist___ goes out of scope
44855- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varlist___ at 10
44856- // parameter-reference list<block_____> blocklist_ goes out of scope
44857- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference blocklist_ at 9
44858- // parameter-reference list<typedef___> typedefs__ goes out of scope
44859- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 8
44860- // parameter-reference list<defidfn___> fndefs____ goes out of scope
44861- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fndefs____ at 7
44862- // parameter-reference list<nametoaddr> translate_ goes out of scope
44863- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference translate_ at 6
44864- // parameter-reference u64 safe______ goes out of scope
44865- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 5
44866- // parameter-reference u64 finite____ goes out of scope
44867- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference finite____ at 4
44868- // parameter-reference u64 complete__ goes out of scope
44869- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference complete__ at 3
44870- // parameter-reference u64 tmpaddr___ goes out of scope
44871- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpaddr___ at 2
44872- // parameter-reference u64 def_id____ goes out of scope
44873- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 1
44874- {
44875- uint64_t baseinfo = heap.data[0].elem1;
44876- struct pair pair = unpair(&heap, &baseinfo);
44877- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
44878- state.addr = pair.elem1;
44879- }
44880- break;
44881- }
4488244109 case 515555125197130432LLU: // allocheap_
4488344110 {
4488444111 {
@@ -44903,7 +44130,7 @@
4490344130 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4490444131 }
4490544132 // ACCUMULATE ARGUMENTS - END
44906- uint64_t return_to = 18446744073709548982LLU;
44133+ uint64_t return_to = 18446744073709549029LLU;
4490744134 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4490844135 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4490944136 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44912,12 +44139,12 @@
4491244139 state.addr = 375116000798050091LLU; // TypeOnHeap
4491344140 break;
4491444141 }
44915- case 18446744073709548982LLU: // 99999999V0'''''''''''''''
44142+ case 18446744073709549029LLU: // 99999999Wj'''''''''''''''
4491644143 {
44917- state.addr = 18446744073709548983LLU; // 99999999V1'''''''''''''''
44144+ state.addr = 18446744073709549030LLU; // 99999999Wk'''''''''''''''
4491844145 break;
4491944146 }
44920- case 18446744073709548983LLU: // 99999999V1'''''''''''''''
44147+ case 18446744073709549030LLU: // 99999999Wk'''''''''''''''
4492144148 {
4492244149 {
4492344150 uint64_t arg = 0LLU;
@@ -44924,10 +44151,10 @@
4492444151 LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4492544152 }
4492644153 /*outofheap_*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*reqsize___*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU) > /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
44927- state.addr = /*outofheap_*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709548981LLU : 18446744073709548980LLU;
44154+ state.addr = /*outofheap_*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709549028LLU : 18446744073709549027LLU;
4492844155 break;
4492944156 }
44930- case 18446744073709548981LLU: // 99999999Vz'''''''''''''''
44157+ case 18446744073709549028LLU: // 99999999Wi'''''''''''''''
4493144158 {
4493244159 // ACCUMULATE ARGUMENTS - BEGIN
4493344160 {
@@ -44935,7 +44162,7 @@
4493544162 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4493644163 }
4493744164 // ACCUMULATE ARGUMENTS - END
44938- uint64_t return_to = 18446744073709548978LLU;
44165+ uint64_t return_to = 18446744073709549025LLU;
4493944166 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4494044167 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4494144168 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44944,12 +44171,12 @@
4494444171 state.addr = 819847183515949359LLU; // reportinit
4494544172 break;
4494644173 }
44947- case 18446744073709548978LLU: // 99999999Vw'''''''''''''''
44174+ case 18446744073709549025LLU: // 99999999Wf'''''''''''''''
4494844175 {
44949- state.addr = 18446744073709548979LLU; // 99999999Vx'''''''''''''''
44176+ state.addr = 18446744073709549026LLU; // 99999999Wg'''''''''''''''
4495044177 break;
4495144178 }
44952- case 18446744073709548979LLU: // 99999999Vx'''''''''''''''
44179+ case 18446744073709549026LLU: // 99999999Wg'''''''''''''''
4495344180 {
4495444181 fprintf(stderr, "%s", "out of heap allocating ");
4495544182 // ACCUMULATE ARGUMENTS - BEGIN
@@ -44958,7 +44185,7 @@
4495844185 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4495944186 }
4496044187 // ACCUMULATE ARGUMENTS - END
44961- uint64_t return_to = 18446744073709548976LLU;
44188+ uint64_t return_to = 18446744073709549023LLU;
4496244189 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4496344190 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4496444191 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44967,12 +44194,12 @@
4496744194 state.addr = 819847183518878432LLU; // reporttype
4496844195 break;
4496944196 }
44970- case 18446744073709548976LLU: // 99999999Vu'''''''''''''''
44197+ case 18446744073709549023LLU: // 99999999Wd'''''''''''''''
4497144198 {
44972- state.addr = 18446744073709548977LLU; // 99999999Vv'''''''''''''''
44199+ state.addr = 18446744073709549024LLU; // 99999999We'''''''''''''''
4497344200 break;
4497444201 }
44975- case 18446744073709548977LLU: // 99999999Vv'''''''''''''''
44202+ case 18446744073709549024LLU: // 99999999We'''''''''''''''
4497644203 {
4497744204 fprintf(stderr, "%s", " ");
4497844205 printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU)));
@@ -44983,7 +44210,7 @@
4498344210 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4498444211 }
4498544212 // ACCUMULATE ARGUMENTS - END
44986- uint64_t return_to = 18446744073709548974LLU;
44213+ uint64_t return_to = 18446744073709549021LLU;
4498744214 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4498844215 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4498944216 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -44992,12 +44219,12 @@
4499244219 state.addr = 819847183517274112LLU; // reportnr__
4499344220 break;
4499444221 }
44995- case 18446744073709548974LLU: // 99999999Vs'''''''''''''''
44222+ case 18446744073709549021LLU: // 99999999Wb'''''''''''''''
4499644223 {
44997- state.addr = 18446744073709548975LLU; // 99999999Vt'''''''''''''''
44224+ state.addr = 18446744073709549022LLU; // 99999999Wc'''''''''''''''
4499844225 break;
4499944226 }
45000- case 18446744073709548975LLU: // 99999999Vt'''''''''''''''
44227+ case 18446744073709549022LLU: // 99999999Wc'''''''''''''''
4500144228 {
4500244229 fprintf(stderr, "%s", " but remaining heap-size is ");
4500344230 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45006,7 +44233,7 @@
4500644233 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4500744234 }
4500844235 // ACCUMULATE ARGUMENTS - END
45009- uint64_t return_to = 18446744073709548972LLU;
44236+ uint64_t return_to = 18446744073709549019LLU;
4501044237 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4501144238 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4501244239 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45015,21 +44242,21 @@
4501544242 state.addr = 819847183517274112LLU; // reportnr__
4501644243 break;
4501744244 }
45018- case 18446744073709548972LLU: // 99999999Vq'''''''''''''''
44245+ case 18446744073709549019LLU: // 99999999W$'''''''''''''''
4501944246 {
45020- state.addr = 18446744073709548973LLU; // 99999999Vr'''''''''''''''
44247+ state.addr = 18446744073709549020LLU; // 99999999Wa'''''''''''''''
4502144248 break;
4502244249 }
45023- case 18446744073709548973LLU: // 99999999Vr'''''''''''''''
44250+ case 18446744073709549020LLU: // 99999999Wa'''''''''''''''
4502444251 {
4502544252 {
4502644253 fprintf(stderr, "%s\n", "");
4502744254 exit(-1);
4502844255 }
45029- state.addr = 18446744073709548980LLU; // 99999999Vy'''''''''''''''
44256+ state.addr = 18446744073709549027LLU; // 99999999Wh'''''''''''''''
4503044257 break;
4503144258 }
45032- case 18446744073709548980LLU: // 99999999Vy'''''''''''''''
44259+ case 18446744073709549027LLU: // 99999999Wh'''''''''''''''
4503344260 {
4503444261 /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)) = /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)) - /*reqsize___*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
4503544262 // variable u64 outofheap_ goes out of scope
@@ -45082,10 +44309,10 @@
4508244309 };
4508344310 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = arg;
4508444311 }
45085- state.addr = 18446744073709548971LLU; // 99999999Vp'''''''''''''''
44312+ state.addr = 18446744073709549018LLU; // 99999999WZ'''''''''''''''
4508644313 break;
4508744314 }
45088- case 18446744073709548971LLU: // 99999999Vp'''''''''''''''
44315+ case 18446744073709549018LLU: // 99999999WZ'''''''''''''''
4508944316 {
4509044317 {
4509144318 uint64_t arg = 0LLU;
@@ -45157,7 +44384,7 @@
4515744384 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4515844385 }
4515944386 // ACCUMULATE ARGUMENTS - END
45160- uint64_t return_to = 18446744073709548967LLU;
44387+ uint64_t return_to = 18446744073709549014LLU;
4516144388 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
4516244389 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4516344390 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45166,20 +44393,20 @@
4516644393 state.addr = 604790753280317473LLU; // findvarref
4516744394 break;
4516844395 }
45169- case 18446744073709548967LLU: // 99999999Vl'''''''''''''''
44396+ case 18446744073709549014LLU: // 99999999WV'''''''''''''''
4517044397 {
45171- state.addr = 18446744073709548968LLU; // 99999999Vm'''''''''''''''
44398+ state.addr = 18446744073709549015LLU; // 99999999WW'''''''''''''''
4517244399 break;
4517344400 }
45174- case 18446744073709548968LLU: // 99999999Vm'''''''''''''''
44401+ case 18446744073709549015LLU: // 99999999WW'''''''''''''''
4517544402 {
4517644403 // variable u64 optelem___ goes out of scope
4517744404 // emitted destructur for type u64
4517844405 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 20
45179- state.addr = 18446744073709548969LLU; // 99999999Vn'''''''''''''''
44406+ state.addr = 18446744073709549016LLU; // 99999999WX'''''''''''''''
4518044407 break;
4518144408 }
45182- case 18446744073709548969LLU: // 99999999Vn'''''''''''''''
44409+ case 18446744073709549016LLU: // 99999999WX'''''''''''''''
4518344410 {
4518444411 // ACCUMULATE ARGUMENTS - BEGIN
4518544412 {
@@ -45203,7 +44430,7 @@
4520344430 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4520444431 }
4520544432 // ACCUMULATE ARGUMENTS - END
45206- uint64_t return_to = 18446744073709548965LLU;
44433+ uint64_t return_to = 18446744073709549012LLU;
4520744434 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4520844435 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4520944436 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45212,12 +44439,12 @@
4521244439 state.addr = 587881357514113024LLU; // emitpar___
4521344440 break;
4521444441 }
45215- case 18446744073709548965LLU: // 99999999Vj'''''''''''''''
44442+ case 18446744073709549012LLU: // 99999999WT'''''''''''''''
4521644443 {
45217- state.addr = 18446744073709548966LLU; // 99999999Vk'''''''''''''''
44444+ state.addr = 18446744073709549013LLU; // 99999999WU'''''''''''''''
4521844445 break;
4521944446 }
45220- case 18446744073709548966LLU: // 99999999Vk'''''''''''''''
44447+ case 18446744073709549013LLU: // 99999999WU'''''''''''''''
4522144448 {
4522244449 // ACCUMULATE ARGUMENTS - BEGIN
4522344450 {
@@ -45225,7 +44452,7 @@
4522544452 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4522644453 }
4522744454 // ACCUMULATE ARGUMENTS - END
45228- uint64_t return_to = 18446744073709548963LLU;
44455+ uint64_t return_to = 18446744073709549010LLU;
4522944456 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4523044457 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4523144458 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45234,12 +44461,12 @@
4523444461 state.addr = 839519719621918720LLU; // skipws____
4523544462 break;
4523644463 }
45237- case 18446744073709548963LLU: // 99999999Vh'''''''''''''''
44464+ case 18446744073709549010LLU: // 99999999WR'''''''''''''''
4523844465 {
45239- state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
44466+ state.addr = 18446744073709549011LLU; // 99999999WS'''''''''''''''
4524044467 break;
4524144468 }
45242- case 18446744073709548964LLU: // 99999999Vi'''''''''''''''
44469+ case 18446744073709549011LLU: // 99999999WS'''''''''''''''
4524344470 {
4524444471 *LOCAL_ACCESS(heap.data, 19LLU, 11LLU) = 46LLU;
4524544472
@@ -45261,7 +44488,7 @@
4526144488 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4526244489 }
4526344490 // ACCUMULATE ARGUMENTS - END
45264- uint64_t return_to = 18446744073709548961LLU;
44491+ uint64_t return_to = 18446744073709549008LLU;
4526544492 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4526644493 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4526744494 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45270,17 +44497,17 @@
4527044497 state.addr = 728666047794575267LLU; // matchoptch
4527144498 break;
4527244499 }
45273- case 18446744073709548961LLU: // 99999999Vf'''''''''''''''
44500+ case 18446744073709549008LLU: // 99999999WP'''''''''''''''
4527444501 {
45275- state.addr = 18446744073709548962LLU; // 99999999Vg'''''''''''''''
44502+ state.addr = 18446744073709549009LLU; // 99999999WQ'''''''''''''''
4527644503 break;
4527744504 }
45278- case 18446744073709548962LLU: // 99999999Vg'''''''''''''''
44505+ case 18446744073709549009LLU: // 99999999WQ'''''''''''''''
4527944506 {
45280- state.addr = /*isdot_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548960LLU : 18446744073709548959LLU;
44507+ state.addr = /*isdot_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709549007LLU : 18446744073709549006LLU;
4528144508 break;
4528244509 }
45283- case 18446744073709548960LLU: // 99999999Ve'''''''''''''''
44510+ case 18446744073709549007LLU: // 99999999WO'''''''''''''''
4528444511 {
4528544512 // ACCUMULATE ARGUMENTS - BEGIN
4528644513 {
@@ -45288,7 +44515,7 @@
4528844515 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4528944516 }
4529044517 // ACCUMULATE ARGUMENTS - END
45291- uint64_t return_to = 18446744073709548957LLU;
44518+ uint64_t return_to = 18446744073709549004LLU;
4529244519 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4529344520 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4529444521 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45297,12 +44524,12 @@
4529744524 state.addr = 819847183515949359LLU; // reportinit
4529844525 break;
4529944526 }
45300- case 18446744073709548957LLU: // 99999999Vb'''''''''''''''
44527+ case 18446744073709549004LLU: // 99999999WL'''''''''''''''
4530144528 {
45302- state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
44529+ state.addr = 18446744073709549005LLU; // 99999999WM'''''''''''''''
4530344530 break;
4530444531 }
45305- case 18446744073709548958LLU: // 99999999Vc'''''''''''''''
44532+ case 18446744073709549005LLU: // 99999999WM'''''''''''''''
4530644533 {
4530744534 fprintf(stderr, "%s", "can't move element (calling constructor ");
4530844535 printid(stderr, /*constrid__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 1LLU)));
@@ -45311,18 +44538,18 @@
4531144538 fprintf(stderr, "%s\n", "");
4531244539 exit(-1);
4531344540 }
45314- state.addr = 18446744073709548959LLU; // 99999999Vd'''''''''''''''
44541+ state.addr = 18446744073709549006LLU; // 99999999WN'''''''''''''''
4531544542 break;
4531644543 }
45317- case 18446744073709548959LLU: // 99999999Vd'''''''''''''''
44544+ case 18446744073709549006LLU: // 99999999WN'''''''''''''''
4531844545 {
4531944546 // variable u64 isdot_____ goes out of scope
4532044547 // emitted destructur for type u64
4532144548 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference isdot_____ at 20
45322- state.addr = 18446744073709548970LLU; // 99999999Vo'''''''''''''''
44549+ state.addr = 18446744073709549017LLU; // 99999999WY'''''''''''''''
4532344550 break;
4532444551 }
45325- case 18446744073709548970LLU: // 99999999Vo'''''''''''''''
44552+ case 18446744073709549017LLU: // 99999999WY'''''''''''''''
4532644553 {
4532744554 {
4532844555 uint64_t arg = 0LLU;
@@ -45342,7 +44569,7 @@
4534244569 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4534344570 }
4534444571 // ACCUMULATE ARGUMENTS - END
45345- uint64_t return_to = 18446744073709548954LLU;
44572+ uint64_t return_to = 18446744073709549001LLU;
4534644573 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4534744574 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4534844575 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45351,12 +44578,12 @@
4535144578 state.addr = 861504787186880512LLU; // typemain__
4535244579 break;
4535344580 }
45354- case 18446744073709548954LLU: // 99999999VZ'''''''''''''''
44581+ case 18446744073709549001LLU: // 99999999WI'''''''''''''''
4535544582 {
45356- state.addr = 18446744073709548955LLU; // 99999999V$'''''''''''''''
44583+ state.addr = 18446744073709549002LLU; // 99999999WJ'''''''''''''''
4535744584 break;
4535844585 }
45359- case 18446744073709548955LLU: // 99999999V$'''''''''''''''
44586+ case 18446744073709549002LLU: // 99999999WJ'''''''''''''''
4536044587 {
4536144588 {
4536244589 uint64_t arg = 0LLU;
@@ -45372,7 +44599,7 @@
4537244599 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4537344600 }
4537444601 // ACCUMULATE ARGUMENTS - END
45375- uint64_t return_to = 18446744073709548952LLU;
44602+ uint64_t return_to = 18446744073709548999LLU;
4537644603 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4537744604 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4537844605 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45381,12 +44608,12 @@
4538144608 state.addr = 861504793962872832LLU; // typesub___
4538244609 break;
4538344610 }
45384- case 18446744073709548952LLU: // 99999999VX'''''''''''''''
44611+ case 18446744073709548999LLU: // 99999999WG'''''''''''''''
4538544612 {
45386- state.addr = 18446744073709548953LLU; // 99999999VY'''''''''''''''
44613+ state.addr = 18446744073709549000LLU; // 99999999WH'''''''''''''''
4538744614 break;
4538844615 }
45389- case 18446744073709548953LLU: // 99999999VY'''''''''''''''
44616+ case 18446744073709549000LLU: // 99999999WH'''''''''''''''
4539044617 {
4539144618 {
4539244619 uint64_t arg = 0LLU;
@@ -45402,7 +44629,7 @@
4540244629 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4540344630 }
4540444631 // ACCUMULATE ARGUMENTS - END
45405- uint64_t return_to = 18446744073709548950LLU;
44632+ uint64_t return_to = 18446744073709548997LLU;
4540644633 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4540744634 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4540844635 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45411,12 +44638,12 @@
4541144638 state.addr = 861504787186880512LLU; // typemain__
4541244639 break;
4541344640 }
45414- case 18446744073709548950LLU: // 99999999VV'''''''''''''''
44641+ case 18446744073709548997LLU: // 99999999WE'''''''''''''''
4541544642 {
45416- state.addr = 18446744073709548951LLU; // 99999999VW'''''''''''''''
44643+ state.addr = 18446744073709548998LLU; // 99999999WF'''''''''''''''
4541744644 break;
4541844645 }
45419- case 18446744073709548951LLU: // 99999999VW'''''''''''''''
44646+ case 18446744073709548998LLU: // 99999999WF'''''''''''''''
4542044647 {
4542144648 {
4542244649 uint64_t arg = 0LLU;
@@ -45432,7 +44659,7 @@
4543244659 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4543344660 }
4543444661 // ACCUMULATE ARGUMENTS - END
45435- uint64_t return_to = 18446744073709548948LLU;
44662+ uint64_t return_to = 18446744073709548995LLU;
4543644663 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4543744664 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4543844665 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45441,18 +44668,18 @@
4544144668 state.addr = 861504793962872832LLU; // typesub___
4544244669 break;
4544344670 }
45444- case 18446744073709548948LLU: // 99999999VT'''''''''''''''
44671+ case 18446744073709548995LLU: // 99999999WC'''''''''''''''
4544544672 {
45446- state.addr = 18446744073709548949LLU; // 99999999VU'''''''''''''''
44673+ state.addr = 18446744073709548996LLU; // 99999999WD'''''''''''''''
4544744674 break;
4544844675 }
45449- case 18446744073709548949LLU: // 99999999VU'''''''''''''''
44676+ case 18446744073709548996LLU: // 99999999WD'''''''''''''''
4545044677 {
4545144678 /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) = /*maintypea_*/*LOCAL_ACCESS(heap.data, 24LLU, 20LLU) != /*maintypeb_*/*LOCAL_ACCESS(heap.data, 24LLU, 22LLU);
45452- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) ? 18446744073709548947LLU : 18446744073709548946LLU;
44679+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) ? 18446744073709548994LLU : 18446744073709548993LLU;
4545344680 break;
4545444681 }
45455- case 18446744073709548947LLU: // 99999999VS'''''''''''''''
44682+ case 18446744073709548994LLU: // 99999999WB'''''''''''''''
4545644683 {
4545744684 // ACCUMULATE ARGUMENTS - BEGIN
4545844685 {
@@ -45460,7 +44687,7 @@
4546044687 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4546144688 }
4546244689 // ACCUMULATE ARGUMENTS - END
45463- uint64_t return_to = 18446744073709548944LLU;
44690+ uint64_t return_to = 18446744073709548991LLU;
4546444691 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4546544692 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4546644693 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45469,12 +44696,12 @@
4546944696 state.addr = 819847183515949359LLU; // reportinit
4547044697 break;
4547144698 }
45472- case 18446744073709548944LLU: // 99999999VP'''''''''''''''
44699+ case 18446744073709548991LLU: // 99999999V9'''''''''''''''
4547344700 {
45474- state.addr = 18446744073709548945LLU; // 99999999VQ'''''''''''''''
44701+ state.addr = 18446744073709548992LLU; // 99999999W_'''''''''''''''
4547544702 break;
4547644703 }
45477- case 18446744073709548945LLU: // 99999999VQ'''''''''''''''
44704+ case 18446744073709548992LLU: // 99999999W_'''''''''''''''
4547844705 {
4547944706 fprintf(stderr, "%s", "[let] ");
4548044707 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45483,7 +44710,7 @@
4548344710 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4548444711 }
4548544712 // ACCUMULATE ARGUMENTS - END
45486- uint64_t return_to = 18446744073709548942LLU;
44713+ uint64_t return_to = 18446744073709548989LLU;
4548744714 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4548844715 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4548944716 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45492,12 +44719,12 @@
4549244719 state.addr = 819847183518878432LLU; // reporttype
4549344720 break;
4549444721 }
45495- case 18446744073709548942LLU: // 99999999VN'''''''''''''''
44722+ case 18446744073709548989LLU: // 99999999V7'''''''''''''''
4549644723 {
45497- state.addr = 18446744073709548943LLU; // 99999999VO'''''''''''''''
44724+ state.addr = 18446744073709548990LLU; // 99999999V8'''''''''''''''
4549844725 break;
4549944726 }
45500- case 18446744073709548943LLU: // 99999999VO'''''''''''''''
44727+ case 18446744073709548990LLU: // 99999999V8'''''''''''''''
4550144728 {
4550244729 fprintf(stderr, "%s", ": ");
4550344730 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45506,7 +44733,7 @@
4550644733 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4550744734 }
4550844735 // ACCUMULATE ARGUMENTS - END
45509- uint64_t return_to = 18446744073709548940LLU;
44736+ uint64_t return_to = 18446744073709548987LLU;
4551044737 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4551144738 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4551244739 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45515,12 +44742,12 @@
4551544742 state.addr = 819847183518878432LLU; // reporttype
4551644743 break;
4551744744 }
45518- case 18446744073709548940LLU: // 99999999VL'''''''''''''''
44745+ case 18446744073709548987LLU: // 99999999V5'''''''''''''''
4551944746 {
45520- state.addr = 18446744073709548941LLU; // 99999999VM'''''''''''''''
44747+ state.addr = 18446744073709548988LLU; // 99999999V6'''''''''''''''
4552144748 break;
4552244749 }
45523- case 18446744073709548941LLU: // 99999999VM'''''''''''''''
44750+ case 18446744073709548988LLU: // 99999999V6'''''''''''''''
4552444751 {
4552544752 fprintf(stderr, "%s", " != ");
4552644753 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45529,7 +44756,7 @@
4552944756 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4553044757 }
4553144758 // ACCUMULATE ARGUMENTS - END
45532- uint64_t return_to = 18446744073709548938LLU;
44759+ uint64_t return_to = 18446744073709548985LLU;
4553344760 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4553444761 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4553544762 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45538,27 +44765,27 @@
4553844765 state.addr = 819847183518878432LLU; // reporttype
4553944766 break;
4554044767 }
45541- case 18446744073709548938LLU: // 99999999VJ'''''''''''''''
44768+ case 18446744073709548985LLU: // 99999999V3'''''''''''''''
4554244769 {
45543- state.addr = 18446744073709548939LLU; // 99999999VK'''''''''''''''
44770+ state.addr = 18446744073709548986LLU; // 99999999V4'''''''''''''''
4554444771 break;
4554544772 }
45546- case 18446744073709548939LLU: // 99999999VK'''''''''''''''
44773+ case 18446744073709548986LLU: // 99999999V4'''''''''''''''
4554744774 {
4554844775 {
4554944776 fprintf(stderr, "%s\n", "");
4555044777 exit(-1);
4555144778 }
45552- state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
44779+ state.addr = 18446744073709548993LLU; // 99999999WA'''''''''''''''
4555344780 break;
4555444781 }
45555- case 18446744073709548946LLU: // 99999999VR'''''''''''''''
44782+ case 18446744073709548993LLU: // 99999999WA'''''''''''''''
4555644783 {
4555744784 /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) = /*subtypea__*/*LOCAL_ACCESS(heap.data, 24LLU, 21LLU) != /*subtypeb__*/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU);
45558- state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) ? 18446744073709548937LLU : 18446744073709548936LLU;
44785+ state.addr = /*result____*/*LOCAL_ACCESS(heap.data, 24LLU, 19LLU) ? 18446744073709548984LLU : 18446744073709548983LLU;
4555944786 break;
4556044787 }
45561- case 18446744073709548937LLU: // 99999999VI'''''''''''''''
44788+ case 18446744073709548984LLU: // 99999999V2'''''''''''''''
4556244789 {
4556344790 // ACCUMULATE ARGUMENTS - BEGIN
4556444791 {
@@ -45566,7 +44793,7 @@
4556644793 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4556744794 }
4556844795 // ACCUMULATE ARGUMENTS - END
45569- uint64_t return_to = 18446744073709548934LLU;
44796+ uint64_t return_to = 18446744073709548981LLU;
4557044797 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4557144798 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4557244799 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45575,12 +44802,12 @@
4557544802 state.addr = 819847183515949359LLU; // reportinit
4557644803 break;
4557744804 }
45578- case 18446744073709548934LLU: // 99999999VF'''''''''''''''
44805+ case 18446744073709548981LLU: // 99999999Vz'''''''''''''''
4557944806 {
45580- state.addr = 18446744073709548935LLU; // 99999999VG'''''''''''''''
44807+ state.addr = 18446744073709548982LLU; // 99999999V0'''''''''''''''
4558144808 break;
4558244809 }
45583- case 18446744073709548935LLU: // 99999999VG'''''''''''''''
44810+ case 18446744073709548982LLU: // 99999999V0'''''''''''''''
4558444811 {
4558544812 fprintf(stderr, "%s", "[let] ");
4558644813 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45589,7 +44816,7 @@
4558944816 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4559044817 }
4559144818 // ACCUMULATE ARGUMENTS - END
45592- uint64_t return_to = 18446744073709548932LLU;
44819+ uint64_t return_to = 18446744073709548979LLU;
4559344820 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4559444821 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4559544822 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45598,12 +44825,12 @@
4559844825 state.addr = 819847183518878432LLU; // reporttype
4559944826 break;
4560044827 }
45601- case 18446744073709548932LLU: // 99999999VD'''''''''''''''
44828+ case 18446744073709548979LLU: // 99999999Vx'''''''''''''''
4560244829 {
45603- state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
44830+ state.addr = 18446744073709548980LLU; // 99999999Vy'''''''''''''''
4560444831 break;
4560544832 }
45606- case 18446744073709548933LLU: // 99999999VE'''''''''''''''
44833+ case 18446744073709548980LLU: // 99999999Vy'''''''''''''''
4560744834 {
4560844835 fprintf(stderr, "%s", ": ");
4560944836 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45612,7 +44839,7 @@
4561244839 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4561344840 }
4561444841 // ACCUMULATE ARGUMENTS - END
45615- uint64_t return_to = 18446744073709548930LLU;
44842+ uint64_t return_to = 18446744073709548977LLU;
4561644843 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4561744844 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4561844845 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45621,12 +44848,12 @@
4562144848 state.addr = 819847183518878432LLU; // reporttype
4562244849 break;
4562344850 }
45624- case 18446744073709548930LLU: // 99999999VB'''''''''''''''
44851+ case 18446744073709548977LLU: // 99999999Vv'''''''''''''''
4562544852 {
45626- state.addr = 18446744073709548931LLU; // 99999999VC'''''''''''''''
44853+ state.addr = 18446744073709548978LLU; // 99999999Vw'''''''''''''''
4562744854 break;
4562844855 }
45629- case 18446744073709548931LLU: // 99999999VC'''''''''''''''
44856+ case 18446744073709548978LLU: // 99999999Vw'''''''''''''''
4563044857 {
4563144858 fprintf(stderr, "%s", " != ");
4563244859 // ACCUMULATE ARGUMENTS - BEGIN
@@ -45635,7 +44862,7 @@
4563544862 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4563644863 }
4563744864 // ACCUMULATE ARGUMENTS - END
45638- uint64_t return_to = 18446744073709548928LLU;
44865+ uint64_t return_to = 18446744073709548975LLU;
4563944866 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4564044867 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4564144868 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45644,21 +44871,21 @@
4564444871 state.addr = 819847183518878432LLU; // reporttype
4564544872 break;
4564644873 }
45647- case 18446744073709548928LLU: // 99999999V_'''''''''''''''
44874+ case 18446744073709548975LLU: // 99999999Vt'''''''''''''''
4564844875 {
45649- state.addr = 18446744073709548929LLU; // 99999999VA'''''''''''''''
44876+ state.addr = 18446744073709548976LLU; // 99999999Vu'''''''''''''''
4565044877 break;
4565144878 }
45652- case 18446744073709548929LLU: // 99999999VA'''''''''''''''
44879+ case 18446744073709548976LLU: // 99999999Vu'''''''''''''''
4565344880 {
4565444881 {
4565544882 fprintf(stderr, "%s\n", "");
4565644883 exit(-1);
4565744884 }
45658- state.addr = 18446744073709548936LLU; // 99999999VH'''''''''''''''
44885+ state.addr = 18446744073709548983LLU; // 99999999V1'''''''''''''''
4565944886 break;
4566044887 }
45661- case 18446744073709548936LLU: // 99999999VH'''''''''''''''
44888+ case 18446744073709548983LLU: // 99999999V1'''''''''''''''
4566244889 {
4566344890 // variable u64 subtypeb__ goes out of scope
4566444891 // emitted destructur for type u64
@@ -45675,10 +44902,10 @@
4567544902 // variable u64 result____ goes out of scope
4567644903 // emitted destructur for type u64
4567744904 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 20
45678- state.addr = 18446744073709548956LLU; // 99999999Va'''''''''''''''
44905+ state.addr = 18446744073709549003LLU; // 99999999WK'''''''''''''''
4567944906 break;
4568044907 }
45681- case 18446744073709548956LLU: // 99999999Va'''''''''''''''
44908+ case 18446744073709549003LLU: // 99999999WK'''''''''''''''
4568244909 {
4568344910 // ACCUMULATE ARGUMENTS - BEGIN
4568444911 {
@@ -45698,7 +44925,7 @@
4569844925 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4569944926 }
4570044927 // ACCUMULATE ARGUMENTS - END
45701- uint64_t return_to = 18446744073709548926LLU;
44928+ uint64_t return_to = 18446744073709548973LLU;
4570244929 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4570344930 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4570444931 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45707,27 +44934,27 @@
4570744934 state.addr = 660220410725010287LLU; // initassert
4570844935 break;
4570944936 }
45710- case 18446744073709548926LLU: // 99999999U8'''''''''''''''
44937+ case 18446744073709548973LLU: // 99999999Vr'''''''''''''''
4571144938 {
45712- state.addr = 18446744073709548927LLU; // 99999999U9'''''''''''''''
44939+ state.addr = 18446744073709548974LLU; // 99999999Vs'''''''''''''''
4571344940 break;
4571444941 }
45715- case 18446744073709548927LLU: // 99999999U9'''''''''''''''
44942+ case 18446744073709548974LLU: // 99999999Vs'''''''''''''''
4571644943 {
45717- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548925LLU : 18446744073709548924LLU;
44944+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548972LLU : 18446744073709548971LLU;
4571844945 break;
4571944946 }
45720- case 18446744073709548925LLU: // 99999999U7'''''''''''''''
44947+ case 18446744073709548972LLU: // 99999999Vq'''''''''''''''
4572144948 {
45722- state.addr = /*parameter_*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548923LLU : 18446744073709548922LLU;
44949+ state.addr = /*parameter_*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548970LLU : 18446744073709548969LLU;
4572344950 break;
4572444951 }
45725- case 18446744073709548923LLU: // 99999999U5'''''''''''''''
44952+ case 18446744073709548970LLU: // 99999999Vo'''''''''''''''
4572644953 {
45727- state.addr = /*consume___*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548921LLU : 18446744073709548920LLU;
44954+ state.addr = /*consume___*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548968LLU : 18446744073709548967LLU;
4572844955 break;
4572944956 }
45730- case 18446744073709548921LLU: // 99999999U3'''''''''''''''
44957+ case 18446744073709548968LLU: // 99999999Vm'''''''''''''''
4573144958 {
4573244959 // ACCUMULATE ARGUMENTS - BEGIN
4573344960 {
@@ -45747,7 +44974,7 @@
4574744974 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4574844975 }
4574944976 // ACCUMULATE ARGUMENTS - END
45750- uint64_t return_to = 18446744073709548918LLU;
44977+ uint64_t return_to = 18446744073709548965LLU;
4575144978 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4575244979 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4575344980 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45756,19 +44983,19 @@
4575644983 state.addr = 732615645798520865LLU; // movevarref
4575744984 break;
4575844985 }
45759- case 18446744073709548918LLU: // 99999999U0'''''''''''''''
44986+ case 18446744073709548965LLU: // 99999999Vj'''''''''''''''
4576044987 {
45761- state.addr = 18446744073709548919LLU; // 99999999U1'''''''''''''''
44988+ state.addr = 18446744073709548966LLU; // 99999999Vk'''''''''''''''
4576244989 break;
4576344990 }
45764- case 18446744073709548919LLU: // 99999999U1'''''''''''''''
44991+ case 18446744073709548966LLU: // 99999999Vk'''''''''''''''
4576544992 {
4576644993 heap.availilable_size_for_dynamic_objects += 0LLU;
4576744994 heap.availilable_size_for_dynamic_objects += 0LLU;
45768- state.addr = 18446744073709548917LLU; // 99999999Uz'''''''''''''''
44995+ state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
4576944996 break;
4577044997 }
45771- case 18446744073709548920LLU: // 99999999U2'''''''''''''''
44998+ case 18446744073709548967LLU: // 99999999Vl'''''''''''''''
4577244999 {
4577345000 // ACCUMULATE ARGUMENTS - BEGIN
4577445001 {
@@ -45776,7 +45003,7 @@
4577645003 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4577745004 }
4577845005 // ACCUMULATE ARGUMENTS - END
45779- uint64_t return_to = 18446744073709548915LLU;
45006+ uint64_t return_to = 18446744073709548962LLU;
4578045007 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4578145008 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4578245009 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45785,12 +45012,12 @@
4578545012 state.addr = 819847183515949359LLU; // reportinit
4578645013 break;
4578745014 }
45788- case 18446744073709548915LLU: // 99999999Ux'''''''''''''''
45015+ case 18446744073709548962LLU: // 99999999Vg'''''''''''''''
4578945016 {
45790- state.addr = 18446744073709548916LLU; // 99999999Uy'''''''''''''''
45017+ state.addr = 18446744073709548963LLU; // 99999999Vh'''''''''''''''
4579145018 break;
4579245019 }
45793- case 18446744073709548916LLU: // 99999999Uy'''''''''''''''
45020+ case 18446744073709548963LLU: // 99999999Vh'''''''''''''''
4579445021 {
4579545022 fprintf(stderr, "%s", "can't move parameter ");
4579645023 printid(stderr, /*argid_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 5LLU)));
@@ -45798,17 +45025,17 @@
4579845025 fprintf(stderr, "%s\n", "");
4579945026 exit(-1);
4580045027 }
45801- state.addr = 18446744073709548917LLU; // 99999999Uz'''''''''''''''
45028+ state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
4580245029 break;
4580345030 }
45804- case 18446744073709548917LLU: // 99999999Uz'''''''''''''''
45031+ case 18446744073709548964LLU: // 99999999Vi'''''''''''''''
4580545032 {
4580645033 heap.availilable_size_for_dynamic_objects += 0LLU;
4580745034 heap.availilable_size_for_dynamic_objects += 0LLU;
45808- state.addr = 18446744073709548914LLU; // 99999999Uw'''''''''''''''
45035+ state.addr = 18446744073709548961LLU; // 99999999Vf'''''''''''''''
4580945036 break;
4581045037 }
45811- case 18446744073709548922LLU: // 99999999U4'''''''''''''''
45038+ case 18446744073709548969LLU: // 99999999Vn'''''''''''''''
4581245039 {
4581345040 // ACCUMULATE ARGUMENTS - BEGIN
4581445041 {
@@ -45828,7 +45055,7 @@
4582845055 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4582945056 }
4583045057 // ACCUMULATE ARGUMENTS - END
45831- uint64_t return_to = 18446744073709548912LLU;
45058+ uint64_t return_to = 18446744073709548959LLU;
4583245059 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4583345060 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4583445061 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45837,24 +45064,24 @@
4583745064 state.addr = 732615645798520865LLU; // movevarref
4583845065 break;
4583945066 }
45840- case 18446744073709548912LLU: // 99999999Uu'''''''''''''''
45067+ case 18446744073709548959LLU: // 99999999Vd'''''''''''''''
4584145068 {
45842- state.addr = 18446744073709548913LLU; // 99999999Uv'''''''''''''''
45069+ state.addr = 18446744073709548960LLU; // 99999999Ve'''''''''''''''
4584345070 break;
4584445071 }
45845- case 18446744073709548913LLU: // 99999999Uv'''''''''''''''
45072+ case 18446744073709548960LLU: // 99999999Ve'''''''''''''''
4584645073 {
45847- state.addr = 18446744073709548914LLU; // 99999999Uw'''''''''''''''
45074+ state.addr = 18446744073709548961LLU; // 99999999Vf'''''''''''''''
4584845075 break;
4584945076 }
45850- case 18446744073709548914LLU: // 99999999Uw'''''''''''''''
45077+ case 18446744073709548961LLU: // 99999999Vf'''''''''''''''
4585145078 {
4585245079 heap.availilable_size_for_dynamic_objects += 0LLU;
4585345080 heap.availilable_size_for_dynamic_objects += 0LLU;
45854- state.addr = 18446744073709548911LLU; // 99999999Ut'''''''''''''''
45081+ state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
4585545082 break;
4585645083 }
45857- case 18446744073709548924LLU: // 99999999U6'''''''''''''''
45084+ case 18446744073709548971LLU: // 99999999Vp'''''''''''''''
4585845085 {
4585945086 // ACCUMULATE ARGUMENTS - BEGIN
4586045087 {
@@ -45862,7 +45089,7 @@
4586245089 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4586345090 }
4586445091 // ACCUMULATE ARGUMENTS - END
45865- uint64_t return_to = 18446744073709548909LLU;
45092+ uint64_t return_to = 18446744073709548956LLU;
4586645093 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4586745094 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4586845095 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45871,12 +45098,12 @@
4587145098 state.addr = 819847183515949359LLU; // reportinit
4587245099 break;
4587345100 }
45874- case 18446744073709548909LLU: // 99999999Ur'''''''''''''''
45101+ case 18446744073709548956LLU: // 99999999Va'''''''''''''''
4587545102 {
45876- state.addr = 18446744073709548910LLU; // 99999999Us'''''''''''''''
45103+ state.addr = 18446744073709548957LLU; // 99999999Vb'''''''''''''''
4587745104 break;
4587845105 }
45879- case 18446744073709548910LLU: // 99999999Us'''''''''''''''
45106+ case 18446744073709548957LLU: // 99999999Vb'''''''''''''''
4588045107 {
4588145108 fprintf(stderr, "%s", "[call to ");
4588245109 printid(stderr, /*constrid__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 1LLU)));
@@ -45886,10 +45113,10 @@
4588645113 fprintf(stderr, "%s\n", "");
4588745114 exit(-1);
4588845115 }
45889- state.addr = 18446744073709548911LLU; // 99999999Ut'''''''''''''''
45116+ state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
4589045117 break;
4589145118 }
45892- case 18446744073709548911LLU: // 99999999Ut'''''''''''''''
45119+ case 18446744073709548958LLU: // 99999999Vc'''''''''''''''
4589345120 {
4589445121 // variable u64 consume___ goes out of scope
4589545122 // emitted destructur for type u64
@@ -45911,7 +45138,7 @@
4591145138 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4591245139 }
4591345140 // ACCUMULATE ARGUMENTS - END
45914- uint64_t return_to = 18446744073709548908LLU;
45141+ uint64_t return_to = 18446744073709548955LLU;
4591545142 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4591645143 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4591745144 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -45920,7 +45147,7 @@
4592045147 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
4592145148 break;
4592245149 }
45923- case 18446744073709548908LLU: // 99999999Uq'''''''''''''''
45150+ case 18446744073709548955LLU: // 99999999V$'''''''''''''''
4592445151 {
4592545152 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typearg___ at 15
4592645153 // variable u64 indirect__ goes out of scope
@@ -45964,10 +45191,10 @@
4596445191 }
4596545192 case 54378275173643538LLU: // CALLCONSTR
4596645193 {
45967- state.addr = 1LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 8LLU))].elem0 ? 18446744073709548907LLU : 18446744073709548906LLU;
45194+ state.addr = 1LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 8LLU))].elem0 ? 18446744073709548954LLU : 18446744073709548953LLU;
4596845195 break;
4596945196 }
45970- case 18446744073709548907LLU: // 99999999Up'''''''''''''''
45197+ case 18446744073709548954LLU: // 99999999VZ'''''''''''''''
4597145198 {
4597245199 {
4597345200 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, *LOCAL_ACCESS(heap.data, 12LLU, 8LLU), 1/*content*/), 0LLU);
@@ -46013,10 +45240,10 @@
4601345240 };
4601445241 *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = arg;
4601545242 }
46016- state.addr = 18446744073709548905LLU; // 99999999Un'''''''''''''''
45243+ state.addr = 18446744073709548952LLU; // 99999999VX'''''''''''''''
4601745244 break;
4601845245 }
46019- case 18446744073709548905LLU: // 99999999Un'''''''''''''''
45246+ case 18446744073709548952LLU: // 99999999VX'''''''''''''''
4602045247 {
4602145248 // ACCUMULATE ARGUMENTS - BEGIN
4602245249 {
@@ -46036,7 +45263,7 @@
4603645263 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4603745264 }
4603845265 // ACCUMULATE ARGUMENTS - END
46039- uint64_t return_to = 18446744073709548903LLU;
45266+ uint64_t return_to = 18446744073709548950LLU;
4604045267 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4604145268 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4604245269 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46045,12 +45272,12 @@
4604545272 state.addr = 621706743143069729LLU; // gettypedef
4604645273 break;
4604745274 }
46048- case 18446744073709548903LLU: // 99999999Ul'''''''''''''''
45275+ case 18446744073709548950LLU: // 99999999VV'''''''''''''''
4604945276 {
46050- state.addr = 18446744073709548904LLU; // 99999999Um'''''''''''''''
45277+ state.addr = 18446744073709548951LLU; // 99999999VW'''''''''''''''
4605145278 break;
4605245279 }
46053- case 18446744073709548904LLU: // 99999999Um'''''''''''''''
45280+ case 18446744073709548951LLU: // 99999999VW'''''''''''''''
4605445281 {
4605545282 {
4605645283 uint64_t arg = tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU), 1LLU);
@@ -46060,10 +45287,10 @@
4606045287 uint64_t arg = tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 18LLU, 16LLU), 2LLU);
4606145288 LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4606245289 }
46063- state.addr = 1LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU))].elem0 ? 18446744073709548901LLU : 18446744073709548900LLU;
45290+ state.addr = 1LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU))].elem0 ? 18446744073709548948LLU : 18446744073709548947LLU;
4606445291 break;
4606545292 }
46066- case 18446744073709548901LLU: // 99999999Uj'''''''''''''''
45293+ case 18446744073709548948LLU: // 99999999VT'''''''''''''''
4606745294 {
4606845295 {
4606945296 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU), 1/*content*/), 0LLU);
@@ -46087,10 +45314,10 @@
4608745314 uint64_t arg = 0;
4608845315 LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4608945316 }
46090- state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
45317+ state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
4609145318 break;
4609245319 }
46093- case 18446744073709548899LLU: // 99999999Uh'''''''''''''''
45320+ case 18446744073709548946LLU: // 99999999VR'''''''''''''''
4609445321 {
4609545322 if(!*LOCAL_ACCESS(heap.data, 24LLU, 22LLU))
4609645323 {
@@ -46097,16 +45324,16 @@
4609745324 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 24
4609845325 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23
4609945326 {
46100- state.addr = 18446744073709548898LLU; // 99999999Ug'''''''''''''''
45327+ state.addr = 18446744073709548945LLU; // 99999999VQ'''''''''''''''
4610145328 break;
4610245329 }
4610345330 }
4610445331 /*direct*/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = (*LOCAL_ACCESS(heap.data, 24LLU, 22LLU) << 1) + 1LLU;
4610545332 *LOCAL_ACCESS(heap.data, 24LLU, 22LLU) = heap.data[*LOCAL_ACCESS(heap.data, 24LLU, 22LLU)].elem0;
46106- state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 24LLU, 21LLU) ? 18446744073709548897LLU : 18446744073709548896LLU;
45333+ state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 24LLU, 21LLU) ? 18446744073709548944LLU : 18446744073709548943LLU;
4610745334 break;
4610845335 }
46109- case 18446744073709548897LLU: // 99999999Uf'''''''''''''''
45336+ case 18446744073709548944LLU: // 99999999VP'''''''''''''''
4611045337 {
4611145338 {
4611245339 uint64_t arg = 0LLU;
@@ -46113,10 +45340,10 @@
4611345340 LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4611445341 }
4611545342 /*foundmatch*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = /*constr____*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 25LLU, 23LLU), 0LLU)) == /*constrid__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 3LLU));
46116- state.addr = /*foundmatch*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709548895LLU : 18446744073709548894LLU;
45343+ state.addr = /*foundmatch*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709548942LLU : 18446744073709548941LLU;
4611745344 break;
4611845345 }
46119- case 18446744073709548895LLU: // 99999999Ud'''''''''''''''
45346+ case 18446744073709548942LLU: // 99999999VN'''''''''''''''
4612045347 {
4612145348 *LOCAL_ACCESS(heap.data, 25LLU, 21LLU) = 0LLU;
4612245349
@@ -46130,7 +45357,7 @@
4613045357 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4613145358 }
4613245359 // ACCUMULATE ARGUMENTS - END
46133- uint64_t return_to = 18446744073709548892LLU;
45360+ uint64_t return_to = 18446744073709548939LLU;
4613445361 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4613545362 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4613645363 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46139,46 +45366,46 @@
4613945366 state.addr = 587581813005601646LLU; // elems2pars
4614045367 break;
4614145368 }
46142- case 18446744073709548892LLU: // 99999999Ua'''''''''''''''
45369+ case 18446744073709548939LLU: // 99999999VK'''''''''''''''
4614345370 {
46144- state.addr = 18446744073709548893LLU; // 99999999Ub'''''''''''''''
45371+ state.addr = 18446744073709548940LLU; // 99999999VL'''''''''''''''
4614545372 break;
4614645373 }
46147- case 18446744073709548893LLU: // 99999999Ub'''''''''''''''
45374+ case 18446744073709548940LLU: // 99999999VL'''''''''''''''
4614845375 {
4614945376 list_reverse(heap.data, &/*elems_____*/*LOCAL_ACCESS(heap.data, 25LLU, 13LLU));
4615045377 heap.availilable_size_for_dynamic_objects += 0LLU;
4615145378 heap.availilable_size_for_dynamic_objects += 0LLU;
46152- state.addr = 18446744073709548891LLU; // 99999999U$'''''''''''''''
45379+ state.addr = 18446744073709548938LLU; // 99999999VJ'''''''''''''''
4615345380 break;
4615445381 }
46155- case 18446744073709548894LLU: // 99999999Uc'''''''''''''''
45382+ case 18446744073709548941LLU: // 99999999VM'''''''''''''''
4615645383 {
4615745384 ++/*variantidx*/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU);
46158- state.addr = 18446744073709548891LLU; // 99999999U$'''''''''''''''
45385+ state.addr = 18446744073709548938LLU; // 99999999VJ'''''''''''''''
4615945386 break;
4616045387 }
46161- case 18446744073709548891LLU: // 99999999U$'''''''''''''''
45388+ case 18446744073709548938LLU: // 99999999VJ'''''''''''''''
4616245389 {
4616345390 // variable u64 foundmatch goes out of scope
4616445391 // emitted destructur for type u64
4616545392 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference foundmatch at 25
46166- state.addr = 18446744073709548896LLU; // 99999999Ue'''''''''''''''
45393+ state.addr = 18446744073709548943LLU; // 99999999VO'''''''''''''''
4616745394 break;
4616845395 }
46169- case 18446744073709548896LLU: // 99999999Ue'''''''''''''''
45396+ case 18446744073709548943LLU: // 99999999VO'''''''''''''''
4617045397 {
4617145398 // parameter-reference variant___ constr____ goes out of scope
4617245399 // parameter-reference list<variant___> constrs___ goes out of scope
46173- state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
45400+ state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
4617445401 break;
4617545402 }
46176- case 18446744073709548898LLU: // 99999999Ug'''''''''''''''
45403+ case 18446744073709548945LLU: // 99999999VQ'''''''''''''''
4617745404 {
46178- state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548890LLU : 18446744073709548889LLU;
45405+ state.addr = /*notfound__*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548937LLU : 18446744073709548936LLU;
4617945406 break;
4618045407 }
46181- case 18446744073709548890LLU: // 99999999UZ'''''''''''''''
45408+ case 18446744073709548937LLU: // 99999999VI'''''''''''''''
4618245409 {
4618345410 // ACCUMULATE ARGUMENTS - BEGIN
4618445411 {
@@ -46186,7 +45413,7 @@
4618645413 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4618745414 }
4618845415 // ACCUMULATE ARGUMENTS - END
46189- uint64_t return_to = 18446744073709548887LLU;
45416+ uint64_t return_to = 18446744073709548934LLU;
4619045417 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4619145418 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4619245419 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46195,12 +45422,12 @@
4619545422 state.addr = 819847183515949359LLU; // reportinit
4619645423 break;
4619745424 }
46198- case 18446744073709548887LLU: // 99999999UW'''''''''''''''
45425+ case 18446744073709548934LLU: // 99999999VF'''''''''''''''
4619945426 {
46200- state.addr = 18446744073709548888LLU; // 99999999UX'''''''''''''''
45427+ state.addr = 18446744073709548935LLU; // 99999999VG'''''''''''''''
4620145428 break;
4620245429 }
46203- case 18446744073709548888LLU: // 99999999UX'''''''''''''''
45430+ case 18446744073709548935LLU: // 99999999VG'''''''''''''''
4620445431 {
4620545432 fprintf(stderr, "%s", "union ");
4620645433 printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 12LLU)));
@@ -46210,10 +45437,10 @@
4621045437 fprintf(stderr, "%s\n", "");
4621145438 exit(-1);
4621245439 }
46213- state.addr = 18446744073709548889LLU; // 99999999UY'''''''''''''''
45440+ state.addr = 18446744073709548936LLU; // 99999999VH'''''''''''''''
4621445441 break;
4621545442 }
46216- case 18446744073709548889LLU: // 99999999UY'''''''''''''''
45443+ case 18446744073709548936LLU: // 99999999VH'''''''''''''''
4621745444 {
4621845445 {
4621945446 uint64_t arg = 0LLU;
@@ -46227,10 +45454,10 @@
4622745454 uint64_t arg = 0;
4622845455 LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4622945456 }
46230- state.addr = 18446744073709548886LLU; // 99999999UV'''''''''''''''
45457+ state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
4623145458 break;
4623245459 }
46233- case 18446744073709548886LLU: // 99999999UV'''''''''''''''
45460+ case 18446744073709548933LLU: // 99999999VE'''''''''''''''
4623445461 {
4623545462 if(!*LOCAL_ACCESS(heap.data, 25LLU, 23LLU))
4623645463 {
@@ -46237,16 +45464,16 @@
4623745464 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 25
4623845465 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 24
4623945466 {
46240- state.addr = 18446744073709548885LLU; // 99999999UU'''''''''''''''
45467+ state.addr = 18446744073709548932LLU; // 99999999VD'''''''''''''''
4624145468 break;
4624245469 }
4624345470 }
4624445471 /*direct*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = (*LOCAL_ACCESS(heap.data, 25LLU, 23LLU) << 1) + 1LLU;
4624545472 *LOCAL_ACCESS(heap.data, 25LLU, 23LLU) = heap.data[*LOCAL_ACCESS(heap.data, 25LLU, 23LLU)].elem0;
46246- state.addr = /*paridx____*/*LOCAL_ACCESS(heap.data, 25LLU, 22LLU) ? 18446744073709548884LLU : 18446744073709548883LLU;
45473+ state.addr = /*paridx____*/*LOCAL_ACCESS(heap.data, 25LLU, 22LLU) ? 18446744073709548931LLU : 18446744073709548930LLU;
4624745474 break;
4624845475 }
46249- case 18446744073709548884LLU: // 99999999UT'''''''''''''''
45476+ case 18446744073709548931LLU: // 99999999VC'''''''''''''''
4625045477 {
4625145478 // ACCUMULATE ARGUMENTS - BEGIN
4625245479 {
@@ -46254,7 +45481,7 @@
4625445481 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4625545482 }
4625645483 // ACCUMULATE ARGUMENTS - END
46257- uint64_t return_to = 18446744073709548881LLU;
45484+ uint64_t return_to = 18446744073709548928LLU;
4625845485 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4625945486 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4626045487 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46263,18 +45490,18 @@
4626345490 state.addr = 839519719621918720LLU; // skipws____
4626445491 break;
4626545492 }
46266- case 18446744073709548881LLU: // 99999999UQ'''''''''''''''
45493+ case 18446744073709548928LLU: // 99999999V_'''''''''''''''
4626745494 {
46268- state.addr = 18446744073709548882LLU; // 99999999UR'''''''''''''''
45495+ state.addr = 18446744073709548929LLU; // 99999999VA'''''''''''''''
4626945496 break;
4627045497 }
46271- case 18446744073709548882LLU: // 99999999UR'''''''''''''''
45498+ case 18446744073709548929LLU: // 99999999VA'''''''''''''''
4627245499 {
4627345500 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)));
46274- state.addr = 18446744073709548883LLU; // 99999999US'''''''''''''''
45501+ state.addr = 18446744073709548930LLU; // 99999999VB'''''''''''''''
4627545502 break;
4627645503 }
46277- case 18446744073709548883LLU: // 99999999US'''''''''''''''
45504+ case 18446744073709548930LLU: // 99999999VB'''''''''''''''
4627845505 {
4627945506 {
4628045507 uint64_t arg = 0LLU;
@@ -46290,7 +45517,7 @@
4629045517 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4629145518 }
4629245519 // ACCUMULATE ARGUMENTS - END
46293- uint64_t return_to = 18446744073709548878LLU;
45520+ uint64_t return_to = 18446744073709548925LLU;
4629445521 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4629545522 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4629645523 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46299,12 +45526,12 @@
4629945526 state.addr = 839519719621918720LLU; // skipws____
4630045527 break;
4630145528 }
46302- case 18446744073709548878LLU: // 99999999UN'''''''''''''''
45529+ case 18446744073709548925LLU: // 99999999U7'''''''''''''''
4630345530 {
46304- state.addr = 18446744073709548879LLU; // 99999999UO'''''''''''''''
45531+ state.addr = 18446744073709548926LLU; // 99999999U8'''''''''''''''
4630545532 break;
4630645533 }
46307- case 18446744073709548879LLU: // 99999999UO'''''''''''''''
45534+ case 18446744073709548926LLU: // 99999999U8'''''''''''''''
4630845535 {
4630945536 // ACCUMULATE ARGUMENTS - BEGIN
4631045537 {
@@ -46316,7 +45543,7 @@
4631645543 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4631745544 }
4631845545 // ACCUMULATE ARGUMENTS - END
46319- uint64_t return_to = 18446744073709548876LLU;
45546+ uint64_t return_to = 18446744073709548923LLU;
4632045547 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4632145548 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4632245549 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46325,17 +45552,17 @@
4632545552 state.addr = 661592067397386240LLU; // isalpha___
4632645553 break;
4632745554 }
46328- case 18446744073709548876LLU: // 99999999UL'''''''''''''''
45555+ case 18446744073709548923LLU: // 99999999U5'''''''''''''''
4632945556 {
46330- state.addr = 18446744073709548877LLU; // 99999999UM'''''''''''''''
45557+ state.addr = 18446744073709548924LLU; // 99999999U6'''''''''''''''
4633145558 break;
4633245559 }
46333- case 18446744073709548877LLU: // 99999999UM'''''''''''''''
45560+ case 18446744073709548924LLU: // 99999999U6'''''''''''''''
4633445561 {
46335- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709548875LLU : 18446744073709548874LLU;
45562+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709548922LLU : 18446744073709548921LLU;
4633645563 break;
4633745564 }
46338- case 18446744073709548875LLU: // 99999999UK'''''''''''''''
45565+ case 18446744073709548922LLU: // 99999999U4'''''''''''''''
4633945566 {
4634045567 {
4634145568 uint64_t arg = 0LLU;
@@ -46347,7 +45574,7 @@
4634745574 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4634845575 }
4634945576 // ACCUMULATE ARGUMENTS - END
46350- uint64_t return_to = 18446744073709548872LLU;
45577+ uint64_t return_to = 18446744073709548919LLU;
4635145578 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4635245579 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4635345580 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46356,12 +45583,12 @@
4635645583 state.addr = 839519719621918720LLU; // skipws____
4635745584 break;
4635845585 }
46359- case 18446744073709548872LLU: // 99999999UH'''''''''''''''
45586+ case 18446744073709548919LLU: // 99999999U1'''''''''''''''
4636045587 {
46361- state.addr = 18446744073709548873LLU; // 99999999UI'''''''''''''''
45588+ state.addr = 18446744073709548920LLU; // 99999999U2'''''''''''''''
4636245589 break;
4636345590 }
46364- case 18446744073709548873LLU: // 99999999UI'''''''''''''''
45591+ case 18446744073709548920LLU: // 99999999U2'''''''''''''''
4636545592 {
4636645593 /*argid_____*/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 5LLU)));
4636745594 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46370,7 +45597,7 @@
4637045597 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4637145598 }
4637245599 // ACCUMULATE ARGUMENTS - END
46373- uint64_t return_to = 18446744073709548870LLU;
45600+ uint64_t return_to = 18446744073709548917LLU;
4637445601 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4637545602 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4637645603 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46379,12 +45606,12 @@
4637945606 state.addr = 839519719621918720LLU; // skipws____
4638045607 break;
4638145608 }
46382- case 18446744073709548870LLU: // 99999999UF'''''''''''''''
45609+ case 18446744073709548917LLU: // 99999999Uz'''''''''''''''
4638345610 {
46384- state.addr = 18446744073709548871LLU; // 99999999UG'''''''''''''''
45611+ state.addr = 18446744073709548918LLU; // 99999999U0'''''''''''''''
4638545612 break;
4638645613 }
46387- case 18446744073709548871LLU: // 99999999UG'''''''''''''''
45614+ case 18446744073709548918LLU: // 99999999U0'''''''''''''''
4638845615 {
4638945616 *LOCAL_ACCESS(heap.data, 28LLU, 25LLU) = 40LLU;
4639045617
@@ -46406,7 +45633,7 @@
4640645633 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4640745634 }
4640845635 // ACCUMULATE ARGUMENTS - END
46409- uint64_t return_to = 18446744073709548868LLU;
45636+ uint64_t return_to = 18446744073709548915LLU;
4641045637 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4641145638 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4641245639 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46415,22 +45642,22 @@
4641545642 state.addr = 728666047794575267LLU; // matchoptch
4641645643 break;
4641745644 }
46418- case 18446744073709548868LLU: // 99999999UD'''''''''''''''
45645+ case 18446744073709548915LLU: // 99999999Ux'''''''''''''''
4641945646 {
46420- state.addr = 18446744073709548869LLU; // 99999999UE'''''''''''''''
45647+ state.addr = 18446744073709548916LLU; // 99999999Uy'''''''''''''''
4642145648 break;
4642245649 }
46423- case 18446744073709548869LLU: // 99999999UE'''''''''''''''
45650+ case 18446744073709548916LLU: // 99999999Uy'''''''''''''''
4642445651 {
46425- state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU) ? 18446744073709548867LLU : 18446744073709548866LLU;
45652+ state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU) ? 18446744073709548914LLU : 18446744073709548913LLU;
4642645653 break;
4642745654 }
46428- case 18446744073709548867LLU: // 99999999UC'''''''''''''''
45655+ case 18446744073709548914LLU: // 99999999Uw'''''''''''''''
4642945656 {
46430- state.addr = (heap.availilable_size_for_dynamic_objects >= (31LLU + 8LLU)) ? 18446744073709548865LLU : 18446744073709548864LLU;
45657+ state.addr = (heap.availilable_size_for_dynamic_objects >= (31LLU + 8LLU)) ? 18446744073709548912LLU : 18446744073709548911LLU;
4643145658 break;
4643245659 }
46433- case 18446744073709548865LLU: // 99999999UA'''''''''''''''
45660+ case 18446744073709548912LLU: // 99999999Uu'''''''''''''''
4643445661 {
4643545662
4643645663 heap.availilable_size_for_dynamic_objects -= (31LLU + 8LLU);
@@ -46442,7 +45669,7 @@
4644245669 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4644345670 }
4644445671 // ACCUMULATE ARGUMENTS - END
46445- uint64_t return_to = 18446744073709548862LLU;
45672+ uint64_t return_to = 18446744073709548909LLU;
4644645673 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4644745674 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4644845675 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46451,12 +45678,12 @@
4645145678 state.addr = 819790006513303552LLU; // recopen___
4645245679 break;
4645345680 }
46454- case 18446744073709548862LLU: // 99999999T8'''''''''''''''
45681+ case 18446744073709548909LLU: // 99999999Ur'''''''''''''''
4645545682 {
46456- state.addr = 18446744073709548863LLU; // 99999999T9'''''''''''''''
45683+ state.addr = 18446744073709548910LLU; // 99999999Us'''''''''''''''
4645745684 break;
4645845685 }
46459- case 18446744073709548863LLU: // 99999999T9'''''''''''''''
45686+ case 18446744073709548910LLU: // 99999999Us'''''''''''''''
4646045687 {
4646145688 fprintf(stdout, "%s", "0LLU");
4646245689 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46509,7 +45736,7 @@
4650945736 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4651045737 }
4651145738 // ACCUMULATE ARGUMENTS - END
46512- uint64_t return_to = 18446744073709548860LLU;
45739+ uint64_t return_to = 18446744073709548907LLU;
4651345740 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
4651445741 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4651545742 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46518,12 +45745,12 @@
4651845745 state.addr = 54378275173643538LLU; // CALLCONSTR
4651945746 break;
4652045747 }
46521- case 18446744073709548860LLU: // 99999999T6'''''''''''''''
45748+ case 18446744073709548907LLU: // 99999999Up'''''''''''''''
4652245749 {
46523- state.addr = 18446744073709548861LLU; // 99999999T7'''''''''''''''
45750+ state.addr = 18446744073709548908LLU; // 99999999Uq'''''''''''''''
4652445751 break;
4652545752 }
46526- case 18446744073709548861LLU: // 99999999T7'''''''''''''''
45753+ case 18446744073709548908LLU: // 99999999Uq'''''''''''''''
4652745754 {
4652845755 // ACCUMULATE ARGUMENTS - BEGIN
4652945756 {
@@ -46535,7 +45762,7 @@
4653545762 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4653645763 }
4653745764 // ACCUMULATE ARGUMENTS - END
46538- uint64_t return_to = 18446744073709548858LLU;
45765+ uint64_t return_to = 18446744073709548905LLU;
4653945766 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4654045767 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4654145768 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46544,12 +45771,12 @@
4654445771 state.addr = 819789177753829376LLU; // recclose__
4654545772 break;
4654645773 }
46547- case 18446744073709548858LLU: // 99999999T4'''''''''''''''
45774+ case 18446744073709548905LLU: // 99999999Un'''''''''''''''
4654845775 {
46549- state.addr = 18446744073709548859LLU; // 99999999T5'''''''''''''''
45776+ state.addr = 18446744073709548906LLU; // 99999999Uo'''''''''''''''
4655045777 break;
4655145778 }
46552- case 18446744073709548859LLU: // 99999999T5'''''''''''''''
45779+ case 18446744073709548906LLU: // 99999999Uo'''''''''''''''
4655345780 {
4655445781 // ACCUMULATE ARGUMENTS - BEGIN
4655545782 {
@@ -46557,7 +45784,7 @@
4655745784 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4655845785 }
4655945786 // ACCUMULATE ARGUMENTS - END
46560- uint64_t return_to = 18446744073709548856LLU;
45787+ uint64_t return_to = 18446744073709548903LLU;
4656145788 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4656245789 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4656345790 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46566,20 +45793,20 @@
4656645793 state.addr = 839519719621918720LLU; // skipws____
4656745794 break;
4656845795 }
46569- case 18446744073709548856LLU: // 99999999T2'''''''''''''''
45796+ case 18446744073709548903LLU: // 99999999Ul'''''''''''''''
4657045797 {
46571- state.addr = 18446744073709548857LLU; // 99999999T3'''''''''''''''
45798+ state.addr = 18446744073709548904LLU; // 99999999Um'''''''''''''''
4657245799 break;
4657345800 }
46574- case 18446744073709548857LLU: // 99999999T3'''''''''''''''
45801+ case 18446744073709548904LLU: // 99999999Um'''''''''''''''
4657545802 {
4657645803 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 29LLU, 5LLU)));
4657745804 heap.availilable_size_for_dynamic_objects += 31LLU;
4657845805 heap.availilable_size_for_dynamic_objects += 8LLU;
46579- state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
45806+ state.addr = 18446744073709548902LLU; // 99999999Uk'''''''''''''''
4658045807 break;
4658145808 }
46582- case 18446744073709548864LLU: // 99999999U_'''''''''''''''
45809+ case 18446744073709548911LLU: // 99999999Ut'''''''''''''''
4658345810 {
4658445811 // ACCUMULATE ARGUMENTS - BEGIN
4658545812 {
@@ -46587,7 +45814,7 @@
4658745814 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4658845815 }
4658945816 // ACCUMULATE ARGUMENTS - END
46590- uint64_t return_to = 18446744073709548853LLU;
45817+ uint64_t return_to = 18446744073709548900LLU;
4659145818 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4659245819 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4659345820 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46596,28 +45823,28 @@
4659645823 state.addr = 819847183515949359LLU; // reportinit
4659745824 break;
4659845825 }
46599- case 18446744073709548853LLU: // 99999999Tz'''''''''''''''
45826+ case 18446744073709548900LLU: // 99999999Ui'''''''''''''''
4660045827 {
46601- state.addr = 18446744073709548854LLU; // 99999999T0'''''''''''''''
45828+ state.addr = 18446744073709548901LLU; // 99999999Uj'''''''''''''''
4660245829 break;
4660345830 }
46604- case 18446744073709548854LLU: // 99999999T0'''''''''''''''
45831+ case 18446744073709548901LLU: // 99999999Uj'''''''''''''''
4660545832 {
4660645833 {
4660745834 fprintf(stderr, "%s\n", "[INTERNAL ERROR, CALLCONSTR] out of memory - recompile compiler with increased heap-size");
4660845835 exit(-1);
4660945836 }
46610- state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
45837+ state.addr = 18446744073709548902LLU; // 99999999Uk'''''''''''''''
4661145838 break;
4661245839 }
46613- case 18446744073709548855LLU: // 99999999T1'''''''''''''''
45840+ case 18446744073709548902LLU: // 99999999Uk'''''''''''''''
4661445841 {
4661545842 heap.availilable_size_for_dynamic_objects += 0LLU;
4661645843 heap.availilable_size_for_dynamic_objects += 0LLU;
46617- state.addr = 18446744073709548852LLU; // 99999999Ty'''''''''''''''
45844+ state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
4661845845 break;
4661945846 }
46620- case 18446744073709548866LLU: // 99999999UB'''''''''''''''
45847+ case 18446744073709548913LLU: // 99999999Uv'''''''''''''''
4662145848 {
4662245849 fprintf(stdout, "%s", ";");
4662345850 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46626,7 +45853,7 @@
4662645853 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4662745854 }
4662845855 // ACCUMULATE ARGUMENTS - END
46629- uint64_t return_to = 18446744073709548850LLU;
45856+ uint64_t return_to = 18446744073709548897LLU;
4663045857 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4663145858 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4663245859 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46635,12 +45862,12 @@
4663545862 state.addr = 660197403663532032LLU; // indent____
4663645863 break;
4663745864 }
46638- case 18446744073709548850LLU: // 99999999Tw'''''''''''''''
45865+ case 18446744073709548897LLU: // 99999999Uf'''''''''''''''
4663945866 {
46640- state.addr = 18446744073709548851LLU; // 99999999Tx'''''''''''''''
45867+ state.addr = 18446744073709548898LLU; // 99999999Ug'''''''''''''''
4664145868 break;
4664245869 }
46643- case 18446744073709548851LLU: // 99999999Tx'''''''''''''''
45870+ case 18446744073709548898LLU: // 99999999Ug'''''''''''''''
4664445871 {
4664545872 fprintf(stdout, "%s", " tree_push_move(&heap, ");
4664645873 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46649,7 +45876,7 @@
4664945876 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4665045877 }
4665145878 // ACCUMULATE ARGUMENTS - END
46652- uint64_t return_to = 18446744073709548848LLU;
45879+ uint64_t return_to = 18446744073709548895LLU;
4665345880 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4665445881 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4665545882 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46658,12 +45885,12 @@
4665845885 state.addr = 787446708198178816LLU; // printnr___
4665945886 break;
4666045887 }
46661- case 18446744073709548848LLU: // 99999999Tu'''''''''''''''
45888+ case 18446744073709548895LLU: // 99999999Ud'''''''''''''''
4666245889 {
46663- state.addr = 18446744073709548849LLU; // 99999999Tv'''''''''''''''
45890+ state.addr = 18446744073709548896LLU; // 99999999Ue'''''''''''''''
4666445891 break;
4666545892 }
46666- case 18446744073709548849LLU: // 99999999Tv'''''''''''''''
45893+ case 18446744073709548896LLU: // 99999999Ue'''''''''''''''
4666745894 {
4666845895 fprintf(stdout, "%s", ", &arg");
4666945896 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46672,7 +45899,7 @@
4667245899 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4667345900 }
4667445901 // ACCUMULATE ARGUMENTS - END
46675- uint64_t return_to = 18446744073709548846LLU;
45902+ uint64_t return_to = 18446744073709548893LLU;
4667645903 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4667745904 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4667845905 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46681,12 +45908,12 @@
4668145908 state.addr = 787446708200409962LLU; // printnzero
4668245909 break;
4668345910 }
46684- case 18446744073709548846LLU: // 99999999Ts'''''''''''''''
45911+ case 18446744073709548893LLU: // 99999999Ub'''''''''''''''
4668545912 {
46686- state.addr = 18446744073709548847LLU; // 99999999Tt'''''''''''''''
45913+ state.addr = 18446744073709548894LLU; // 99999999Uc'''''''''''''''
4668745914 break;
4668845915 }
46689- case 18446744073709548847LLU: // 99999999Tt'''''''''''''''
45916+ case 18446744073709548894LLU: // 99999999Uc'''''''''''''''
4669045917 {
4669145918 fprintf(stdout, "%s", ", &");
4669245919 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46735,7 +45962,7 @@
4673545962 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4673645963 }
4673745964 // ACCUMULATE ARGUMENTS - END
46738- uint64_t return_to = 18446744073709548844LLU;
45965+ uint64_t return_to = 18446744073709548891LLU;
4673945966 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
4674045967 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4674145968 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46744,18 +45971,18 @@
4674445971 state.addr = 552437436537559168LLU; // constrarg_
4674545972 break;
4674645973 }
46747- case 18446744073709548844LLU: // 99999999Tq'''''''''''''''
45974+ case 18446744073709548891LLU: // 99999999U$'''''''''''''''
4674845975 {
46749- state.addr = 18446744073709548845LLU; // 99999999Tr'''''''''''''''
45976+ state.addr = 18446744073709548892LLU; // 99999999Ua'''''''''''''''
4675045977 break;
4675145978 }
46752- case 18446744073709548845LLU: // 99999999Tr'''''''''''''''
45979+ case 18446744073709548892LLU: // 99999999Ua'''''''''''''''
4675345980 {
4675445981 fprintf(stdout, "%s", ")");
46755- state.addr = 18446744073709548852LLU; // 99999999Ty'''''''''''''''
45982+ state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
4675645983 break;
4675745984 }
46758- case 18446744073709548852LLU: // 99999999Ty'''''''''''''''
45985+ case 18446744073709548899LLU: // 99999999Uh'''''''''''''''
4675945986 {
4676045987 // variable u64 called____ goes out of scope
4676145988 // emitted destructur for type u64
@@ -46765,10 +45992,10 @@
4676545992 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference argid_____ at 28
4676645993 heap.availilable_size_for_dynamic_objects += 0LLU;
4676745994 heap.availilable_size_for_dynamic_objects += 0LLU;
46768- state.addr = 18446744073709548843LLU; // 99999999Tp'''''''''''''''
45995+ state.addr = 18446744073709548890LLU; // 99999999UZ'''''''''''''''
4676945996 break;
4677045997 }
46771- case 18446744073709548874LLU: // 99999999UJ'''''''''''''''
45998+ case 18446744073709548921LLU: // 99999999U3'''''''''''''''
4677245999 {
4677346000 {
4677446001 uint64_t arg = 0LLU;
@@ -46782,7 +46009,7 @@
4678246009 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4678346010 }
4678446011 // ACCUMULATE ARGUMENTS - END
46785- uint64_t return_to = 18446744073709548841LLU;
46012+ uint64_t return_to = 18446744073709548888LLU;
4678646013 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4678746014 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4678846015 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46791,12 +46018,12 @@
4679146018 state.addr = 660197403663532032LLU; // indent____
4679246019 break;
4679346020 }
46794- case 18446744073709548841LLU: // 99999999Tn'''''''''''''''
46021+ case 18446744073709548888LLU: // 99999999UX'''''''''''''''
4679546022 {
46796- state.addr = 18446744073709548842LLU; // 99999999To'''''''''''''''
46023+ state.addr = 18446744073709548889LLU; // 99999999UY'''''''''''''''
4679746024 break;
4679846025 }
46799- case 18446744073709548842LLU: // 99999999To'''''''''''''''
46026+ case 18446744073709548889LLU: // 99999999UY'''''''''''''''
4680046027 {
4680146028 fprintf(stdout, "%s", " {");
4680246029 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46805,7 +46032,7 @@
4680546032 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4680646033 }
4680746034 // ACCUMULATE ARGUMENTS - END
46808- uint64_t return_to = 18446744073709548839LLU;
46035+ uint64_t return_to = 18446744073709548886LLU;
4680946036 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4681046037 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4681146038 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46814,12 +46041,12 @@
4681446041 state.addr = 660197403663532032LLU; // indent____
4681546042 break;
4681646043 }
46817- case 18446744073709548839LLU: // 99999999Tl'''''''''''''''
46044+ case 18446744073709548886LLU: // 99999999UV'''''''''''''''
4681846045 {
46819- state.addr = 18446744073709548840LLU; // 99999999Tm'''''''''''''''
46046+ state.addr = 18446744073709548887LLU; // 99999999UW'''''''''''''''
4682046047 break;
4682146048 }
46822- case 18446744073709548840LLU: // 99999999Tm'''''''''''''''
46049+ case 18446744073709548887LLU: // 99999999UW'''''''''''''''
4682346050 {
4682446051 fprintf(stdout, "%s", " uint64_t value = ");
4682546052 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46828,7 +46055,7 @@
4682846055 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4682946056 }
4683046057 // ACCUMULATE ARGUMENTS - END
46831- uint64_t return_to = 18446744073709548837LLU;
46058+ uint64_t return_to = 18446744073709548884LLU;
4683246059 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4683346060 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4683446061 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46837,12 +46064,12 @@
4683746064 state.addr = 787446708198178816LLU; // printnr___
4683846065 break;
4683946066 }
46840- case 18446744073709548837LLU: // 99999999Tj'''''''''''''''
46067+ case 18446744073709548884LLU: // 99999999UT'''''''''''''''
4684146068 {
46842- state.addr = 18446744073709548838LLU; // 99999999Tk'''''''''''''''
46069+ state.addr = 18446744073709548885LLU; // 99999999UU'''''''''''''''
4684346070 break;
4684446071 }
46845- case 18446744073709548838LLU: // 99999999Tk'''''''''''''''
46072+ case 18446744073709548885LLU: // 99999999UU'''''''''''''''
4684646073 {
4684746074 fprintf(stdout, "%s", ";");
4684846075 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46851,7 +46078,7 @@
4685146078 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4685246079 }
4685346080 // ACCUMULATE ARGUMENTS - END
46854- uint64_t return_to = 18446744073709548835LLU;
46081+ uint64_t return_to = 18446744073709548882LLU;
4685546082 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4685646083 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4685746084 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46860,12 +46087,12 @@
4686046087 state.addr = 660197403663532032LLU; // indent____
4686146088 break;
4686246089 }
46863- case 18446744073709548835LLU: // 99999999Th'''''''''''''''
46090+ case 18446744073709548882LLU: // 99999999UR'''''''''''''''
4686446091 {
46865- state.addr = 18446744073709548836LLU; // 99999999Ti'''''''''''''''
46092+ state.addr = 18446744073709548883LLU; // 99999999US'''''''''''''''
4686646093 break;
4686746094 }
46868- case 18446744073709548836LLU: // 99999999Ti'''''''''''''''
46095+ case 18446744073709548883LLU: // 99999999US'''''''''''''''
4686946096 {
4687046097 fprintf(stdout, "%s", " tree_push_move(&heap, ");
4687146098 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46874,7 +46101,7 @@
4687446101 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4687546102 }
4687646103 // ACCUMULATE ARGUMENTS - END
46877- uint64_t return_to = 18446744073709548833LLU;
46104+ uint64_t return_to = 18446744073709548880LLU;
4687846105 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4687946106 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4688046107 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46883,12 +46110,12 @@
4688346110 state.addr = 787446708198178816LLU; // printnr___
4688446111 break;
4688546112 }
46886- case 18446744073709548833LLU: // 99999999Tf'''''''''''''''
46113+ case 18446744073709548880LLU: // 99999999UP'''''''''''''''
4688746114 {
46888- state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
46115+ state.addr = 18446744073709548881LLU; // 99999999UQ'''''''''''''''
4688946116 break;
4689046117 }
46891- case 18446744073709548834LLU: // 99999999Tg'''''''''''''''
46118+ case 18446744073709548881LLU: // 99999999UQ'''''''''''''''
4689246119 {
4689346120 fprintf(stdout, "%s", ", &arg");
4689446121 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46897,7 +46124,7 @@
4689746124 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4689846125 }
4689946126 // ACCUMULATE ARGUMENTS - END
46900- uint64_t return_to = 18446744073709548831LLU;
46127+ uint64_t return_to = 18446744073709548878LLU;
4690146128 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4690246129 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4690346130 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46906,12 +46133,12 @@
4690646133 state.addr = 787446708200409962LLU; // printnzero
4690746134 break;
4690846135 }
46909- case 18446744073709548831LLU: // 99999999Td'''''''''''''''
46136+ case 18446744073709548878LLU: // 99999999UN'''''''''''''''
4691046137 {
46911- state.addr = 18446744073709548832LLU; // 99999999Te'''''''''''''''
46138+ state.addr = 18446744073709548879LLU; // 99999999UO'''''''''''''''
4691246139 break;
4691346140 }
46914- case 18446744073709548832LLU: // 99999999Te'''''''''''''''
46141+ case 18446744073709548879LLU: // 99999999UO'''''''''''''''
4691546142 {
4691646143 fprintf(stdout, "%s", ", &value");
4691746144 fprintf(stdout, "%s", ");");
@@ -46921,7 +46148,7 @@
4692146148 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4692246149 }
4692346150 // ACCUMULATE ARGUMENTS - END
46924- uint64_t return_to = 18446744073709548829LLU;
46151+ uint64_t return_to = 18446744073709548876LLU;
4692546152 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4692646153 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4692746154 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46930,21 +46157,21 @@
4693046157 state.addr = 660197403663532032LLU; // indent____
4693146158 break;
4693246159 }
46933- case 18446744073709548829LLU: // 99999999Tb'''''''''''''''
46160+ case 18446744073709548876LLU: // 99999999UL'''''''''''''''
4693446161 {
46935- state.addr = 18446744073709548830LLU; // 99999999Tc'''''''''''''''
46162+ state.addr = 18446744073709548877LLU; // 99999999UM'''''''''''''''
4693646163 break;
4693746164 }
46938- case 18446744073709548830LLU: // 99999999Tc'''''''''''''''
46165+ case 18446744073709548877LLU: // 99999999UM'''''''''''''''
4693946166 {
4694046167 fprintf(stdout, "%s", " }");
4694146168 // variable u64 nr________ goes out of scope
4694246169 // emitted destructur for type u64
4694346170 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 28
46944- state.addr = 18446744073709548843LLU; // 99999999Tp'''''''''''''''
46171+ state.addr = 18446744073709548890LLU; // 99999999UZ'''''''''''''''
4694546172 break;
4694646173 }
46947- case 18446744073709548843LLU: // 99999999Tp'''''''''''''''
46174+ case 18446744073709548890LLU: // 99999999UZ'''''''''''''''
4694846175 {
4694946176 // variable u64 matchsym__ goes out of scope
4695046177 // emitted destructur for type u64
@@ -46952,18 +46179,18 @@
4695246179 // variable u64 sym_______ goes out of scope
4695346180 // emitted destructur for type u64
4695446181 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 26
46955- state.addr = 18446744073709548880LLU; // 99999999UP'''''''''''''''
46182+ state.addr = 18446744073709548927LLU; // 99999999U9'''''''''''''''
4695646183 break;
4695746184 }
46958- case 18446744073709548880LLU: // 99999999UP'''''''''''''''
46185+ case 18446744073709548927LLU: // 99999999U9'''''''''''''''
4695946186 {
4696046187 ++/*paridx____*/*LOCAL_ACCESS(heap.data, 25LLU, 22LLU);
4696146188 // parameter-reference pardef____ elem______ goes out of scope
4696246189 // parameter list<pardef____> elems_____ goes out of scope
46963- state.addr = 18446744073709548886LLU; // 99999999UV'''''''''''''''
46190+ state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
4696446191 break;
4696546192 }
46966- case 18446744073709548885LLU: // 99999999UU'''''''''''''''
46193+ case 18446744073709548932LLU: // 99999999VD'''''''''''''''
4696746194 {
4696846195 fprintf(stdout, "%s", ";");
4696946196 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46972,7 +46199,7 @@
4697246199 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4697346200 }
4697446201 // ACCUMULATE ARGUMENTS - END
46975- uint64_t return_to = 18446744073709548826LLU;
46202+ uint64_t return_to = 18446744073709548873LLU;
4697646203 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4697746204 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4697846205 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -46981,12 +46208,12 @@
4698146208 state.addr = 660197403663532032LLU; // indent____
4698246209 break;
4698346210 }
46984- case 18446744073709548826LLU: // 99999999TZ'''''''''''''''
46211+ case 18446744073709548873LLU: // 99999999UI'''''''''''''''
4698546212 {
46986- state.addr = 18446744073709548827LLU; // 99999999T$'''''''''''''''
46213+ state.addr = 18446744073709548874LLU; // 99999999UJ'''''''''''''''
4698746214 break;
4698846215 }
46989- case 18446744073709548827LLU: // 99999999T$'''''''''''''''
46216+ case 18446744073709548874LLU: // 99999999UJ'''''''''''''''
4699046217 {
4699146218 fprintf(stdout, "%s", " {");
4699246219 // ACCUMULATE ARGUMENTS - BEGIN
@@ -46995,7 +46222,7 @@
4699546222 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4699646223 }
4699746224 // ACCUMULATE ARGUMENTS - END
46998- uint64_t return_to = 18446744073709548824LLU;
46225+ uint64_t return_to = 18446744073709548871LLU;
4699946226 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4700046227 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4700146228 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47004,12 +46231,12 @@
4700446231 state.addr = 660197403663532032LLU; // indent____
4700546232 break;
4700646233 }
47007- case 18446744073709548824LLU: // 99999999TX'''''''''''''''
46234+ case 18446744073709548871LLU: // 99999999UG'''''''''''''''
4700846235 {
47009- state.addr = 18446744073709548825LLU; // 99999999TY'''''''''''''''
46236+ state.addr = 18446744073709548872LLU; // 99999999UH'''''''''''''''
4701046237 break;
4701146238 }
47012- case 18446744073709548825LLU: // 99999999TY'''''''''''''''
46239+ case 18446744073709548872LLU: // 99999999UH'''''''''''''''
4701346240 {
4701446241 fprintf(stdout, "%s", " uint64_t constridx = ");
4701546242 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47018,7 +46245,7 @@
4701846245 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4701946246 }
4702046247 // ACCUMULATE ARGUMENTS - END
47021- uint64_t return_to = 18446744073709548822LLU;
46248+ uint64_t return_to = 18446744073709548869LLU;
4702246249 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4702346250 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4702446251 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47027,12 +46254,12 @@
4702746254 state.addr = 787446708198178816LLU; // printnr___
4702846255 break;
4702946256 }
47030- case 18446744073709548822LLU: // 99999999TV'''''''''''''''
46257+ case 18446744073709548869LLU: // 99999999UE'''''''''''''''
4703146258 {
47032- state.addr = 18446744073709548823LLU; // 99999999TW'''''''''''''''
46259+ state.addr = 18446744073709548870LLU; // 99999999UF'''''''''''''''
4703346260 break;
4703446261 }
47035- case 18446744073709548823LLU: // 99999999TW'''''''''''''''
46262+ case 18446744073709548870LLU: // 99999999UF'''''''''''''''
4703646263 {
4703746264 fprintf(stdout, "%s", "; // ");
4703846265 printid(stdout, /*constrid__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 3LLU)));
@@ -47042,7 +46269,7 @@
4704246269 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4704346270 }
4704446271 // ACCUMULATE ARGUMENTS - END
47045- uint64_t return_to = 18446744073709548820LLU;
46272+ uint64_t return_to = 18446744073709548867LLU;
4704646273 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4704746274 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4704846275 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47051,12 +46278,12 @@
4705146278 state.addr = 660197403663532032LLU; // indent____
4705246279 break;
4705346280 }
47054- case 18446744073709548820LLU: // 99999999TT'''''''''''''''
46281+ case 18446744073709548867LLU: // 99999999UC'''''''''''''''
4705546282 {
47056- state.addr = 18446744073709548821LLU; // 99999999TU'''''''''''''''
46283+ state.addr = 18446744073709548868LLU; // 99999999UD'''''''''''''''
4705746284 break;
4705846285 }
47059- case 18446744073709548821LLU: // 99999999TU'''''''''''''''
46286+ case 18446744073709548868LLU: // 99999999UD'''''''''''''''
4706046287 {
4706146288 fprintf(stdout, "%s", " arg");
4706246289 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47065,7 +46292,7 @@
4706546292 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4706646293 }
4706746294 // ACCUMULATE ARGUMENTS - END
47068- uint64_t return_to = 18446744073709548818LLU;
46295+ uint64_t return_to = 18446744073709548865LLU;
4706946296 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4707046297 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4707146298 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47074,12 +46301,12 @@
4707446301 state.addr = 787446708200409962LLU; // printnzero
4707546302 break;
4707646303 }
47077- case 18446744073709548818LLU: // 99999999TR'''''''''''''''
46304+ case 18446744073709548865LLU: // 99999999UA'''''''''''''''
4707846305 {
47079- state.addr = 18446744073709548819LLU; // 99999999TS'''''''''''''''
46306+ state.addr = 18446744073709548866LLU; // 99999999UB'''''''''''''''
4708046307 break;
4708146308 }
47082- case 18446744073709548819LLU: // 99999999TS'''''''''''''''
46309+ case 18446744073709548866LLU: // 99999999UB'''''''''''''''
4708346310 {
4708446311 fprintf(stdout, "%s", " = pair_move(&heap, &constridx, &arg");
4708546312 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47088,7 +46315,7 @@
4708846315 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4708946316 }
4709046317 // ACCUMULATE ARGUMENTS - END
47091- uint64_t return_to = 18446744073709548816LLU;
46318+ uint64_t return_to = 18446744073709548863LLU;
4709246319 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4709346320 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4709446321 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47097,12 +46324,12 @@
4709746324 state.addr = 787446708200409962LLU; // printnzero
4709846325 break;
4709946326 }
47100- case 18446744073709548816LLU: // 99999999TP'''''''''''''''
46327+ case 18446744073709548863LLU: // 99999999T9'''''''''''''''
4710146328 {
47102- state.addr = 18446744073709548817LLU; // 99999999TQ'''''''''''''''
46329+ state.addr = 18446744073709548864LLU; // 99999999U_'''''''''''''''
4710346330 break;
4710446331 }
47105- case 18446744073709548817LLU: // 99999999TQ'''''''''''''''
46332+ case 18446744073709548864LLU: // 99999999U_'''''''''''''''
4710646333 {
4710746334 fprintf(stdout, "%s", ");");
4710846335 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47111,7 +46338,7 @@
4711146338 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4711246339 }
4711346340 // ACCUMULATE ARGUMENTS - END
47114- uint64_t return_to = 18446744073709548814LLU;
46341+ uint64_t return_to = 18446744073709548861LLU;
4711546342 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4711646343 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4711746344 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47120,18 +46347,18 @@
4712046347 state.addr = 660197403663532032LLU; // indent____
4712146348 break;
4712246349 }
47123- case 18446744073709548814LLU: // 99999999TN'''''''''''''''
46350+ case 18446744073709548861LLU: // 99999999T7'''''''''''''''
4712446351 {
47125- state.addr = 18446744073709548815LLU; // 99999999TO'''''''''''''''
46352+ state.addr = 18446744073709548862LLU; // 99999999T8'''''''''''''''
4712646353 break;
4712746354 }
47128- case 18446744073709548815LLU: // 99999999TO'''''''''''''''
46355+ case 18446744073709548862LLU: // 99999999T8'''''''''''''''
4712946356 {
4713046357 fprintf(stdout, "%s", " }");
47131- state.addr = 18446744073709548828LLU; // 99999999Ta'''''''''''''''
46358+ state.addr = 18446744073709548875LLU; // 99999999UK'''''''''''''''
4713246359 break;
4713346360 }
47134- case 18446744073709548828LLU: // 99999999Ta'''''''''''''''
46361+ case 18446744073709548875LLU: // 99999999UK'''''''''''''''
4713546362 {
4713646363 // variable u64 paridx____ goes out of scope
4713746364 // emitted destructur for type u64
@@ -47146,10 +46373,10 @@
4714646373 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference constrs___ at 20
4714746374 heap.availilable_size_for_dynamic_objects += 0LLU;
4714846375 heap.availilable_size_for_dynamic_objects += 0LLU;
47149- state.addr = 18446744073709548813LLU; // 99999999TM'''''''''''''''
46376+ state.addr = 18446744073709548860LLU; // 99999999T6'''''''''''''''
4715046377 break;
4715146378 }
47152- case 18446744073709548900LLU: // 99999999Ui'''''''''''''''
46379+ case 18446744073709548947LLU: // 99999999VS'''''''''''''''
4715346380 {
4715446381 // ACCUMULATE ARGUMENTS - BEGIN
4715546382 {
@@ -47169,7 +46396,7 @@
4716946396 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4717046397 }
4717146398 // ACCUMULATE ARGUMENTS - END
47172- uint64_t return_to = 18446744073709548811LLU;
46399+ uint64_t return_to = 18446744073709548858LLU;
4717346400 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4717446401 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4717546402 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47178,17 +46405,17 @@
4717846405 state.addr = 621706727380746240LLU; // gettk_____
4717946406 break;
4718046407 }
47181- case 18446744073709548811LLU: // 99999999TK'''''''''''''''
46408+ case 18446744073709548858LLU: // 99999999T4'''''''''''''''
4718246409 {
47183- state.addr = 18446744073709548812LLU; // 99999999TL'''''''''''''''
46410+ state.addr = 18446744073709548859LLU; // 99999999T5'''''''''''''''
4718446411 break;
4718546412 }
47186- case 18446744073709548812LLU: // 99999999TL'''''''''''''''
46413+ case 18446744073709548859LLU: // 99999999T5'''''''''''''''
4718746414 {
47188- state.addr = 0LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU))].elem0 ? 18446744073709548810LLU : 18446744073709548809LLU;
46415+ state.addr = 0LLU == heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU))].elem0 ? 18446744073709548857LLU : 18446744073709548856LLU;
4718946416 break;
4719046417 }
47191- case 18446744073709548810LLU: // 99999999TJ'''''''''''''''
46418+ case 18446744073709548857LLU: // 99999999T3'''''''''''''''
4719246419 {
4719346420 {
4719446421 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU), 1/*content*/), 0LLU);
@@ -47204,10 +46431,10 @@
4720446431 uint64_t arg = 0;
4720546432 LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4720646433 }
47207- state.addr = 18446744073709548808LLU; // 99999999TH'''''''''''''''
46434+ state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
4720846435 break;
4720946436 }
47210- case 18446744073709548808LLU: // 99999999TH'''''''''''''''
46437+ case 18446744073709548855LLU: // 99999999T1'''''''''''''''
4721146438 {
4721246439 if(!*LOCAL_ACCESS(heap.data, 22LLU, 20LLU))
4721346440 {
@@ -47214,7 +46441,7 @@
4721446441 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22
4721546442 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21
4721646443 {
47217- state.addr = 18446744073709548807LLU; // 99999999TG'''''''''''''''
46444+ state.addr = 18446744073709548854LLU; // 99999999T0'''''''''''''''
4721846445 break;
4721946446 }
4722046447 }
@@ -47242,7 +46469,7 @@
4724246469 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4724346470 }
4724446471 // ACCUMULATE ARGUMENTS - END
47245- uint64_t return_to = 18446744073709548805LLU;
46472+ uint64_t return_to = 18446744073709548852LLU;
4724646473 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4724746474 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4724846475 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47251,12 +46478,12 @@
4725146478 state.addr = 367395560426147840LLU; // TYPECOPY__
4725246479 break;
4725346480 }
47254- case 18446744073709548805LLU: // 99999999TE'''''''''''''''
46481+ case 18446744073709548852LLU: // 99999999Ty'''''''''''''''
4725546482 {
47256- state.addr = 18446744073709548806LLU; // 99999999TF'''''''''''''''
46483+ state.addr = 18446744073709548853LLU; // 99999999Tz'''''''''''''''
4725746484 break;
4725846485 }
47259- case 18446744073709548806LLU: // 99999999TF'''''''''''''''
46486+ case 18446744073709548853LLU: // 99999999Tz'''''''''''''''
4726046487 {
4726146488 {
4726246489 uint64_t arg = 0;
@@ -47270,10 +46497,10 @@
4727046497 };
4727146498 *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = arg;
4727246499 }
47273- state.addr = 18446744073709548804LLU; // 99999999TD'''''''''''''''
46500+ state.addr = 18446744073709548851LLU; // 99999999Tx'''''''''''''''
4727446501 break;
4727546502 }
47276- case 18446744073709548804LLU: // 99999999TD'''''''''''''''
46503+ case 18446744073709548851LLU: // 99999999Tx'''''''''''''''
4727746504 {
4727846505 {
4727946506 uint64_t arg = 0;
@@ -47287,15 +46514,15 @@
4728746514 tree_push_move(&heap, 3LLU, &arg, &*LOCAL_ACCESS(heap.data, 27LLU, 23LLU));
4728846515 *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = arg;
4728946516 }
47290- state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
46517+ state.addr = 18446744073709548850LLU; // 99999999Tw'''''''''''''''
4729146518 break;
4729246519 }
47293- case 18446744073709548803LLU: // 99999999TC'''''''''''''''
46520+ case 18446744073709548850LLU: // 99999999Tw'''''''''''''''
4729446521 {
47295- state.addr = !list_push_move(&heap, &/*newpar____*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU), &/*elems_____*/*LOCAL_ACCESS(heap.data, 27LLU, 13LLU), 11) ? 18446744073709548802LLU : 18446744073709548801LLU;
46522+ state.addr = !list_push_move(&heap, &/*newpar____*/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU), &/*elems_____*/*LOCAL_ACCESS(heap.data, 27LLU, 13LLU), 11) ? 18446744073709548849LLU : 18446744073709548848LLU;
4729646523 break;
4729746524 }
47298- case 18446744073709548802LLU: // 99999999TB'''''''''''''''
46525+ case 18446744073709548849LLU: // 99999999Tv'''''''''''''''
4729946526 {
4730046527 {
4730146528 uint64_t arg = *LOCAL_ACCESS(heap.data, 27LLU, 26LLU);
@@ -47308,7 +46535,7 @@
4730846535 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4730946536 }
4731046537 // ACCUMULATE ARGUMENTS - END
47311- uint64_t return_to = 18446744073709548799LLU;
46538+ uint64_t return_to = 18446744073709548846LLU;
4731246539 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4731346540 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4731446541 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47317,12 +46544,12 @@
4731746544 state.addr = 819847183518878432LLU; // reporttype
4731846545 break;
4731946546 }
47320- case 18446744073709548799LLU: // 99999999S9'''''''''''''''
46547+ case 18446744073709548846LLU: // 99999999Ts'''''''''''''''
4732146548 {
47322- state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
46549+ state.addr = 18446744073709548847LLU; // 99999999Tt'''''''''''''''
4732346550 break;
4732446551 }
47325- case 18446744073709548800LLU: // 99999999T_'''''''''''''''
46552+ case 18446744073709548847LLU: // 99999999Tt'''''''''''''''
4732646553 {
4732746554 fprintf(stderr, "%s", "\n");
4732846555 {
@@ -47337,7 +46564,7 @@
4733746564 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4733846565 }
4733946566 // ACCUMULATE ARGUMENTS - END
47340- uint64_t return_to = 18446744073709548798LLU;
46567+ uint64_t return_to = 18446744073709548845LLU;
4734146568 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4734246569 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4734346570 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47346,20 +46573,20 @@
4734646573 state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
4734746574 break;
4734846575 }
47349- case 18446744073709548798LLU: // 99999999S8'''''''''''''''
46576+ case 18446744073709548845LLU: // 99999999Tr'''''''''''''''
4735046577 {
4735146578 (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newpar____ at 28
4735246579 heap.availilable_size_for_dynamic_objects += 0LLU;
4735346580 heap.availilable_size_for_dynamic_objects += 0LLU;
47354- state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
46581+ state.addr = 18446744073709548844LLU; // 99999999Tq'''''''''''''''
4735546582 break;
4735646583 }
47357- case 18446744073709548801LLU: // 99999999TA'''''''''''''''
46584+ case 18446744073709548848LLU: // 99999999Tu'''''''''''''''
4735846585 {
47359- state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
46586+ state.addr = 18446744073709548844LLU; // 99999999Tq'''''''''''''''
4736046587 break;
4736146588 }
47362- case 18446744073709548797LLU: // 99999999S7'''''''''''''''
46589+ case 18446744073709548844LLU: // 99999999Tq'''''''''''''''
4736346590 {
4736446591 // variable pardef____ newpar____ goes out of scope
4736546592 // (uninitialized -> no destructor-call)
@@ -47378,10 +46605,10 @@
4737846605 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 23
4737946606 // parameter-reference elemdef___ par_______ goes out of scope
4738046607 // parameter-reference list<elemdef___> defpars___ goes out of scope
47381- state.addr = 18446744073709548808LLU; // 99999999TH'''''''''''''''
46608+ state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
4738246609 break;
4738346610 }
47384- case 18446744073709548807LLU: // 99999999TG'''''''''''''''
46611+ case 18446744073709548854LLU: // 99999999T0'''''''''''''''
4738546612 {
4738646613 list_reverse(heap.data, &/*elems_____*/*LOCAL_ACCESS(heap.data, 20LLU, 13LLU));
4738746614 {
@@ -47401,10 +46628,10 @@
4740146628 };
4740246629 *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = arg;
4740346630 }
47404- state.addr = 18446744073709548796LLU; // 99999999S6'''''''''''''''
46631+ state.addr = 18446744073709548843LLU; // 99999999Tp'''''''''''''''
4740546632 break;
4740646633 }
47407- case 18446744073709548796LLU: // 99999999S6'''''''''''''''
46634+ case 18446744073709548843LLU: // 99999999Tp'''''''''''''''
4740846635 {
4740946636 // ACCUMULATE ARGUMENTS - BEGIN
4741046637 {
@@ -47424,7 +46651,7 @@
4742446651 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4742546652 }
4742646653 // ACCUMULATE ARGUMENTS - END
47427- uint64_t return_to = 18446744073709548794LLU;
46654+ uint64_t return_to = 18446744073709548841LLU;
4742846655 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4742946656 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4743046657 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47433,12 +46660,12 @@
4743346660 state.addr = 861504774606571689LLU; // typeassign
4743446661 break;
4743546662 }
47436- case 18446744073709548794LLU: // 99999999S4'''''''''''''''
46663+ case 18446744073709548841LLU: // 99999999Tn'''''''''''''''
4743746664 {
47438- state.addr = 18446744073709548795LLU; // 99999999S5'''''''''''''''
46665+ state.addr = 18446744073709548842LLU; // 99999999To'''''''''''''''
4743946666 break;
4744046667 }
47441- case 18446744073709548795LLU: // 99999999S5'''''''''''''''
46668+ case 18446744073709548842LLU: // 99999999To'''''''''''''''
4744246669 {
4744346670 // variable type______ srctype___ goes out of scope
4744446671 // emitted destructur for type type______
@@ -47448,7 +46675,7 @@
4744846675 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4744946676 }
4745046677 // ACCUMULATE ARGUMENTS - END
47451- uint64_t return_to = 18446744073709548793LLU;
46678+ uint64_t return_to = 18446744073709548840LLU;
4745246679 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4745346680 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4745446681 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47457,7 +46684,7 @@
4745746684 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
4745846685 break;
4745946686 }
47460- case 18446744073709548793LLU: // 99999999S3'''''''''''''''
46687+ case 18446744073709548840LLU: // 99999999Tm'''''''''''''''
4746146688 {
4746246689 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srctype___ at 22
4746346690 // variable u64 constrid__ goes out of scope
@@ -47467,10 +46694,10 @@
4746746694 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defpars___ at 20
4746846695 heap.availilable_size_for_dynamic_objects += 0LLU;
4746946696 heap.availilable_size_for_dynamic_objects += 0LLU;
47470- state.addr = 18446744073709548792LLU; // 99999999S2'''''''''''''''
46697+ state.addr = 18446744073709548839LLU; // 99999999Tl'''''''''''''''
4747146698 break;
4747246699 }
47473- case 18446744073709548809LLU: // 99999999TI'''''''''''''''
46700+ case 18446744073709548856LLU: // 99999999T2'''''''''''''''
4747446701 {
4747546702 // ACCUMULATE ARGUMENTS - BEGIN
4747646703 {
@@ -47478,7 +46705,7 @@
4747846705 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4747946706 }
4748046707 // ACCUMULATE ARGUMENTS - END
47481- uint64_t return_to = 18446744073709548790LLU;
46708+ uint64_t return_to = 18446744073709548837LLU;
4748246709 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4748346710 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4748446711 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47487,12 +46714,12 @@
4748746714 state.addr = 819847183515949359LLU; // reportinit
4748846715 break;
4748946716 }
47490- case 18446744073709548790LLU: // 99999999S0'''''''''''''''
46717+ case 18446744073709548837LLU: // 99999999Tj'''''''''''''''
4749146718 {
47492- state.addr = 18446744073709548791LLU; // 99999999S1'''''''''''''''
46719+ state.addr = 18446744073709548838LLU; // 99999999Tk'''''''''''''''
4749346720 break;
4749446721 }
47495- case 18446744073709548791LLU: // 99999999S1'''''''''''''''
46722+ case 18446744073709548838LLU: // 99999999Tk'''''''''''''''
4749646723 {
4749746724 // ACCUMULATE ARGUMENTS - BEGIN
4749846725 {
@@ -47500,7 +46727,7 @@
4750046727 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4750146728 }
4750246729 // ACCUMULATE ARGUMENTS - END
47503- uint64_t return_to = 18446744073709548788LLU;
46730+ uint64_t return_to = 18446744073709548835LLU;
4750446731 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4750546732 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4750646733 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47509,12 +46736,12 @@
4750946736 state.addr = 819847183518878432LLU; // reporttype
4751046737 break;
4751146738 }
47512- case 18446744073709548788LLU: // 99999999Sy'''''''''''''''
46739+ case 18446744073709548835LLU: // 99999999Th'''''''''''''''
4751346740 {
47514- state.addr = 18446744073709548789LLU; // 99999999Sz'''''''''''''''
46741+ state.addr = 18446744073709548836LLU; // 99999999Ti'''''''''''''''
4751546742 break;
4751646743 }
47517- case 18446744073709548789LLU: // 99999999Sz'''''''''''''''
46744+ case 18446744073709548836LLU: // 99999999Ti'''''''''''''''
4751846745 {
4751946746 fprintf(stderr, "%s", " ");
4752046747 printid(stderr, /*constrid__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 3LLU)));
@@ -47523,10 +46750,10 @@
4752346750 fprintf(stderr, "%s\n", "");
4752446751 exit(-1);
4752546752 }
47526- state.addr = 18446744073709548792LLU; // 99999999S2'''''''''''''''
46753+ state.addr = 18446744073709548839LLU; // 99999999Tl'''''''''''''''
4752746754 break;
4752846755 }
47529- case 18446744073709548792LLU: // 99999999S2'''''''''''''''
46756+ case 18446744073709548839LLU: // 99999999Tl'''''''''''''''
4753046757 {
4753146758 {
4753246759 uint64_t arg = 0LLU;
@@ -47540,10 +46767,10 @@
4754046767 uint64_t arg = 0;
4754146768 LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4754246769 }
47543- state.addr = 18446744073709548787LLU; // 99999999Sx'''''''''''''''
46770+ state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
4754446771 break;
4754546772 }
47546- case 18446744073709548787LLU: // 99999999Sx'''''''''''''''
46773+ case 18446744073709548834LLU: // 99999999Tg'''''''''''''''
4754746774 {
4754846775 if(!*LOCAL_ACCESS(heap.data, 22LLU, 20LLU))
4754946776 {
@@ -47550,16 +46777,16 @@
4755046777 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22
4755146778 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21
4755246779 {
47553- state.addr = 18446744073709548786LLU; // 99999999Sw'''''''''''''''
46780+ state.addr = 18446744073709548833LLU; // 99999999Tf'''''''''''''''
4755446781 break;
4755546782 }
4755646783 }
4755746784 /*direct*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = (*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) << 1) + 1LLU;
4755846785 *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = heap.data[*LOCAL_ACCESS(heap.data, 22LLU, 20LLU)].elem0;
47559- state.addr = /*paridx____*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) ? 18446744073709548785LLU : 18446744073709548784LLU;
46786+ state.addr = /*paridx____*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) ? 18446744073709548832LLU : 18446744073709548831LLU;
4756046787 break;
4756146788 }
47562- case 18446744073709548785LLU: // 99999999Sv'''''''''''''''
46789+ case 18446744073709548832LLU: // 99999999Te'''''''''''''''
4756346790 {
4756446791 // ACCUMULATE ARGUMENTS - BEGIN
4756546792 {
@@ -47567,7 +46794,7 @@
4756746794 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4756846795 }
4756946796 // ACCUMULATE ARGUMENTS - END
47570- uint64_t return_to = 18446744073709548782LLU;
46797+ uint64_t return_to = 18446744073709548829LLU;
4757146798 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4757246799 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4757346800 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47576,18 +46803,18 @@
4757646803 state.addr = 839519719621918720LLU; // skipws____
4757746804 break;
4757846805 }
47579- case 18446744073709548782LLU: // 99999999Ss'''''''''''''''
46806+ case 18446744073709548829LLU: // 99999999Tb'''''''''''''''
4758046807 {
47581- state.addr = 18446744073709548783LLU; // 99999999St'''''''''''''''
46808+ state.addr = 18446744073709548830LLU; // 99999999Tc'''''''''''''''
4758246809 break;
4758346810 }
47584- case 18446744073709548783LLU: // 99999999St'''''''''''''''
46811+ case 18446744073709548830LLU: // 99999999Tc'''''''''''''''
4758546812 {
4758646813 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
47587- state.addr = 18446744073709548784LLU; // 99999999Su'''''''''''''''
46814+ state.addr = 18446744073709548831LLU; // 99999999Td'''''''''''''''
4758846815 break;
4758946816 }
47590- case 18446744073709548784LLU: // 99999999Su'''''''''''''''
46817+ case 18446744073709548831LLU: // 99999999Td'''''''''''''''
4759146818 {
4759246819 {
4759346820 uint64_t arg = 0LLU;
@@ -47603,7 +46830,7 @@
4760346830 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4760446831 }
4760546832 // ACCUMULATE ARGUMENTS - END
47606- uint64_t return_to = 18446744073709548779LLU;
46833+ uint64_t return_to = 18446744073709548826LLU;
4760746834 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4760846835 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4760946836 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47612,12 +46839,12 @@
4761246839 state.addr = 839519719621918720LLU; // skipws____
4761346840 break;
4761446841 }
47615- case 18446744073709548779LLU: // 99999999Sp'''''''''''''''
46842+ case 18446744073709548826LLU: // 99999999TZ'''''''''''''''
4761646843 {
47617- state.addr = 18446744073709548780LLU; // 99999999Sq'''''''''''''''
46844+ state.addr = 18446744073709548827LLU; // 99999999T$'''''''''''''''
4761846845 break;
4761946846 }
47620- case 18446744073709548780LLU: // 99999999Sq'''''''''''''''
46847+ case 18446744073709548827LLU: // 99999999T$'''''''''''''''
4762146848 {
4762246849 // ACCUMULATE ARGUMENTS - BEGIN
4762346850 {
@@ -47629,7 +46856,7 @@
4762946856 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4763046857 }
4763146858 // ACCUMULATE ARGUMENTS - END
47632- uint64_t return_to = 18446744073709548777LLU;
46859+ uint64_t return_to = 18446744073709548824LLU;
4763346860 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4763446861 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4763546862 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47638,17 +46865,17 @@
4763846865 state.addr = 661592067397386240LLU; // isalpha___
4763946866 break;
4764046867 }
47641- case 18446744073709548777LLU: // 99999999Sn'''''''''''''''
46868+ case 18446744073709548824LLU: // 99999999TX'''''''''''''''
4764246869 {
47643- state.addr = 18446744073709548778LLU; // 99999999So'''''''''''''''
46870+ state.addr = 18446744073709548825LLU; // 99999999TY'''''''''''''''
4764446871 break;
4764546872 }
47646- case 18446744073709548778LLU: // 99999999So'''''''''''''''
46873+ case 18446744073709548825LLU: // 99999999TY'''''''''''''''
4764746874 {
47648- state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) ? 18446744073709548776LLU : 18446744073709548775LLU;
46875+ state.addr = /*matchsym__*/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) ? 18446744073709548823LLU : 18446744073709548822LLU;
4764946876 break;
4765046877 }
47651- case 18446744073709548776LLU: // 99999999Sm'''''''''''''''
46878+ case 18446744073709548823LLU: // 99999999TW'''''''''''''''
4765246879 {
4765346880 {
4765446881 uint64_t arg = 0LLU;
@@ -47660,7 +46887,7 @@
4766046887 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4766146888 }
4766246889 // ACCUMULATE ARGUMENTS - END
47663- uint64_t return_to = 18446744073709548773LLU;
46890+ uint64_t return_to = 18446744073709548820LLU;
4766446891 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4766546892 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4766646893 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47669,12 +46896,12 @@
4766946896 state.addr = 839519719621918720LLU; // skipws____
4767046897 break;
4767146898 }
47672- case 18446744073709548773LLU: // 99999999Sj'''''''''''''''
46899+ case 18446744073709548820LLU: // 99999999TT'''''''''''''''
4767346900 {
47674- state.addr = 18446744073709548774LLU; // 99999999Sk'''''''''''''''
46901+ state.addr = 18446744073709548821LLU; // 99999999TU'''''''''''''''
4767546902 break;
4767646903 }
47677- case 18446744073709548774LLU: // 99999999Sk'''''''''''''''
46904+ case 18446744073709548821LLU: // 99999999TU'''''''''''''''
4767846905 {
4767946906 /*argid_____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)));
4768046907 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47683,7 +46910,7 @@
4768346910 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4768446911 }
4768546912 // ACCUMULATE ARGUMENTS - END
47686- uint64_t return_to = 18446744073709548771LLU;
46913+ uint64_t return_to = 18446744073709548818LLU;
4768746914 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4768846915 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4768946916 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47692,12 +46919,12 @@
4769246919 state.addr = 839519719621918720LLU; // skipws____
4769346920 break;
4769446921 }
47695- case 18446744073709548771LLU: // 99999999Sh'''''''''''''''
46922+ case 18446744073709548818LLU: // 99999999TR'''''''''''''''
4769646923 {
47697- state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
46924+ state.addr = 18446744073709548819LLU; // 99999999TS'''''''''''''''
4769846925 break;
4769946926 }
47700- case 18446744073709548772LLU: // 99999999Si'''''''''''''''
46927+ case 18446744073709548819LLU: // 99999999TS'''''''''''''''
4770146928 {
4770246929 *LOCAL_ACCESS(heap.data, 25LLU, 22LLU) = 40LLU;
4770346930
@@ -47719,7 +46946,7 @@
4771946946 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4772046947 }
4772146948 // ACCUMULATE ARGUMENTS - END
47722- uint64_t return_to = 18446744073709548769LLU;
46949+ uint64_t return_to = 18446744073709548816LLU;
4772346950 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4772446951 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4772546952 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47728,22 +46955,22 @@
4772846955 state.addr = 728666047794575267LLU; // matchoptch
4772946956 break;
4773046957 }
47731- case 18446744073709548769LLU: // 99999999Sf'''''''''''''''
46958+ case 18446744073709548816LLU: // 99999999TP'''''''''''''''
4773246959 {
47733- state.addr = 18446744073709548770LLU; // 99999999Sg'''''''''''''''
46960+ state.addr = 18446744073709548817LLU; // 99999999TQ'''''''''''''''
4773446961 break;
4773546962 }
47736- case 18446744073709548770LLU: // 99999999Sg'''''''''''''''
46963+ case 18446744073709548817LLU: // 99999999TQ'''''''''''''''
4773746964 {
47738- state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548768LLU : 18446744073709548767LLU;
46965+ state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548815LLU : 18446744073709548814LLU;
4773946966 break;
4774046967 }
47741- case 18446744073709548768LLU: // 99999999Se'''''''''''''''
46968+ case 18446744073709548815LLU: // 99999999TO'''''''''''''''
4774246969 {
47743- state.addr = (heap.availilable_size_for_dynamic_objects >= (27LLU + 8LLU)) ? 18446744073709548766LLU : 18446744073709548765LLU;
46970+ state.addr = (heap.availilable_size_for_dynamic_objects >= (27LLU + 8LLU)) ? 18446744073709548813LLU : 18446744073709548812LLU;
4774446971 break;
4774546972 }
47746- case 18446744073709548766LLU: // 99999999Sc'''''''''''''''
46973+ case 18446744073709548813LLU: // 99999999TM'''''''''''''''
4774746974 {
4774846975
4774946976 heap.availilable_size_for_dynamic_objects -= (27LLU + 8LLU);
@@ -47755,7 +46982,7 @@
4775546982 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4775646983 }
4775746984 // ACCUMULATE ARGUMENTS - END
47758- uint64_t return_to = 18446744073709548763LLU;
46985+ uint64_t return_to = 18446744073709548810LLU;
4775946986 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4776046987 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4776146988 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47764,12 +46991,12 @@
4776446991 state.addr = 819790006513303552LLU; // recopen___
4776546992 break;
4776646993 }
47767- case 18446744073709548763LLU: // 99999999S$'''''''''''''''
46994+ case 18446744073709548810LLU: // 99999999TJ'''''''''''''''
4776846995 {
47769- state.addr = 18446744073709548764LLU; // 99999999Sa'''''''''''''''
46996+ state.addr = 18446744073709548811LLU; // 99999999TK'''''''''''''''
4777046997 break;
4777146998 }
47772- case 18446744073709548764LLU: // 99999999Sa'''''''''''''''
46999+ case 18446744073709548811LLU: // 99999999TK'''''''''''''''
4777347000 {
4777447001 fprintf(stdout, "%s", "0LLU");
4777547002 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47822,7 +47049,7 @@
4782247049 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4782347050 }
4782447051 // ACCUMULATE ARGUMENTS - END
47825- uint64_t return_to = 18446744073709548761LLU;
47052+ uint64_t return_to = 18446744073709548808LLU;
4782647053 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
4782747054 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4782847055 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47831,12 +47058,12 @@
4783147058 state.addr = 54378275173643538LLU; // CALLCONSTR
4783247059 break;
4783347060 }
47834- case 18446744073709548761LLU: // 99999999SY'''''''''''''''
47061+ case 18446744073709548808LLU: // 99999999TH'''''''''''''''
4783547062 {
47836- state.addr = 18446744073709548762LLU; // 99999999SZ'''''''''''''''
47063+ state.addr = 18446744073709548809LLU; // 99999999TI'''''''''''''''
4783747064 break;
4783847065 }
47839- case 18446744073709548762LLU: // 99999999SZ'''''''''''''''
47066+ case 18446744073709548809LLU: // 99999999TI'''''''''''''''
4784047067 {
4784147068 // ACCUMULATE ARGUMENTS - BEGIN
4784247069 {
@@ -47848,7 +47075,7 @@
4784847075 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4784947076 }
4785047077 // ACCUMULATE ARGUMENTS - END
47851- uint64_t return_to = 18446744073709548759LLU;
47078+ uint64_t return_to = 18446744073709548806LLU;
4785247079 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4785347080 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4785447081 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47857,12 +47084,12 @@
4785747084 state.addr = 819789177753829376LLU; // recclose__
4785847085 break;
4785947086 }
47860- case 18446744073709548759LLU: // 99999999SW'''''''''''''''
47087+ case 18446744073709548806LLU: // 99999999TF'''''''''''''''
4786147088 {
47862- state.addr = 18446744073709548760LLU; // 99999999SX'''''''''''''''
47089+ state.addr = 18446744073709548807LLU; // 99999999TG'''''''''''''''
4786347090 break;
4786447091 }
47865- case 18446744073709548760LLU: // 99999999SX'''''''''''''''
47092+ case 18446744073709548807LLU: // 99999999TG'''''''''''''''
4786647093 {
4786747094 // ACCUMULATE ARGUMENTS - BEGIN
4786847095 {
@@ -47870,7 +47097,7 @@
4787047097 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4787147098 }
4787247099 // ACCUMULATE ARGUMENTS - END
47873- uint64_t return_to = 18446744073709548757LLU;
47100+ uint64_t return_to = 18446744073709548804LLU;
4787447101 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4787547102 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4787647103 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47879,20 +47106,20 @@
4787947106 state.addr = 839519719621918720LLU; // skipws____
4788047107 break;
4788147108 }
47882- case 18446744073709548757LLU: // 99999999SU'''''''''''''''
47109+ case 18446744073709548804LLU: // 99999999TD'''''''''''''''
4788347110 {
47884- state.addr = 18446744073709548758LLU; // 99999999SV'''''''''''''''
47111+ state.addr = 18446744073709548805LLU; // 99999999TE'''''''''''''''
4788547112 break;
4788647113 }
47887- case 18446744073709548758LLU: // 99999999SV'''''''''''''''
47114+ case 18446744073709548805LLU: // 99999999TE'''''''''''''''
4788847115 {
4788947116 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 26LLU, 5LLU)));
4789047117 heap.availilable_size_for_dynamic_objects += 27LLU;
4789147118 heap.availilable_size_for_dynamic_objects += 8LLU;
47892- state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
47119+ state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
4789347120 break;
4789447121 }
47895- case 18446744073709548765LLU: // 99999999Sb'''''''''''''''
47122+ case 18446744073709548812LLU: // 99999999TL'''''''''''''''
4789647123 {
4789747124 // ACCUMULATE ARGUMENTS - BEGIN
4789847125 {
@@ -47900,7 +47127,7 @@
4790047127 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4790147128 }
4790247129 // ACCUMULATE ARGUMENTS - END
47903- uint64_t return_to = 18446744073709548754LLU;
47130+ uint64_t return_to = 18446744073709548801LLU;
4790447131 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4790547132 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4790647133 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47909,28 +47136,28 @@
4790947136 state.addr = 819847183515949359LLU; // reportinit
4791047137 break;
4791147138 }
47912- case 18446744073709548754LLU: // 99999999SR'''''''''''''''
47139+ case 18446744073709548801LLU: // 99999999TA'''''''''''''''
4791347140 {
47914- state.addr = 18446744073709548755LLU; // 99999999SS'''''''''''''''
47141+ state.addr = 18446744073709548802LLU; // 99999999TB'''''''''''''''
4791547142 break;
4791647143 }
47917- case 18446744073709548755LLU: // 99999999SS'''''''''''''''
47144+ case 18446744073709548802LLU: // 99999999TB'''''''''''''''
4791847145 {
4791947146 {
4792047147 fprintf(stderr, "%s\n", "[INTERNAL ERROR, CALLCONSTR] out of memory - recompile compiler with increased heap-size");
4792147148 exit(-1);
4792247149 }
47923- state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
47150+ state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
4792447151 break;
4792547152 }
47926- case 18446744073709548756LLU: // 99999999ST'''''''''''''''
47153+ case 18446744073709548803LLU: // 99999999TC'''''''''''''''
4792747154 {
4792847155 heap.availilable_size_for_dynamic_objects += 0LLU;
4792947156 heap.availilable_size_for_dynamic_objects += 0LLU;
47930- state.addr = 18446744073709548753LLU; // 99999999SQ'''''''''''''''
47157+ state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
4793147158 break;
4793247159 }
47933- case 18446744073709548767LLU: // 99999999Sd'''''''''''''''
47160+ case 18446744073709548814LLU: // 99999999TN'''''''''''''''
4793447161 {
4793547162 fprintf(stdout, "%s", ";");
4793647163 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47939,7 +47166,7 @@
4793947166 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4794047167 }
4794147168 // ACCUMULATE ARGUMENTS - END
47942- uint64_t return_to = 18446744073709548751LLU;
47169+ uint64_t return_to = 18446744073709548798LLU;
4794347170 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4794447171 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4794547172 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47948,12 +47175,12 @@
4794847175 state.addr = 660197403663532032LLU; // indent____
4794947176 break;
4795047177 }
47951- case 18446744073709548751LLU: // 99999999SO'''''''''''''''
47178+ case 18446744073709548798LLU: // 99999999S8'''''''''''''''
4795247179 {
47953- state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
47180+ state.addr = 18446744073709548799LLU; // 99999999S9'''''''''''''''
4795447181 break;
4795547182 }
47956- case 18446744073709548752LLU: // 99999999SP'''''''''''''''
47183+ case 18446744073709548799LLU: // 99999999S9'''''''''''''''
4795747184 {
4795847185 fprintf(stdout, "%s", " tree_push_move(&heap, ");
4795947186 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47962,7 +47189,7 @@
4796247189 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4796347190 }
4796447191 // ACCUMULATE ARGUMENTS - END
47965- uint64_t return_to = 18446744073709548749LLU;
47192+ uint64_t return_to = 18446744073709548796LLU;
4796647193 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4796747194 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4796847195 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47971,12 +47198,12 @@
4797147198 state.addr = 787446708198178816LLU; // printnr___
4797247199 break;
4797347200 }
47974- case 18446744073709548749LLU: // 99999999SM'''''''''''''''
47201+ case 18446744073709548796LLU: // 99999999S6'''''''''''''''
4797547202 {
47976- state.addr = 18446744073709548750LLU; // 99999999SN'''''''''''''''
47203+ state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
4797747204 break;
4797847205 }
47979- case 18446744073709548750LLU: // 99999999SN'''''''''''''''
47206+ case 18446744073709548797LLU: // 99999999S7'''''''''''''''
4798047207 {
4798147208 fprintf(stdout, "%s", ", &arg");
4798247209 // ACCUMULATE ARGUMENTS - BEGIN
@@ -47985,7 +47212,7 @@
4798547212 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4798647213 }
4798747214 // ACCUMULATE ARGUMENTS - END
47988- uint64_t return_to = 18446744073709548747LLU;
47215+ uint64_t return_to = 18446744073709548794LLU;
4798947216 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4799047217 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4799147218 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -47994,12 +47221,12 @@
4799447221 state.addr = 787446708200409962LLU; // printnzero
4799547222 break;
4799647223 }
47997- case 18446744073709548747LLU: // 99999999SK'''''''''''''''
47224+ case 18446744073709548794LLU: // 99999999S4'''''''''''''''
4799847225 {
47999- state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
47226+ state.addr = 18446744073709548795LLU; // 99999999S5'''''''''''''''
4800047227 break;
4800147228 }
48002- case 18446744073709548748LLU: // 99999999SL'''''''''''''''
47229+ case 18446744073709548795LLU: // 99999999S5'''''''''''''''
4800347230 {
4800447231 fprintf(stdout, "%s", ", &");
4800547232 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48048,7 +47275,7 @@
4804847275 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4804947276 }
4805047277 // ACCUMULATE ARGUMENTS - END
48051- uint64_t return_to = 18446744073709548745LLU;
47278+ uint64_t return_to = 18446744073709548792LLU;
4805247279 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
4805347280 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4805447281 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48057,18 +47284,18 @@
4805747284 state.addr = 552437436537559168LLU; // constrarg_
4805847285 break;
4805947286 }
48060- case 18446744073709548745LLU: // 99999999SI'''''''''''''''
47287+ case 18446744073709548792LLU: // 99999999S2'''''''''''''''
4806147288 {
48062- state.addr = 18446744073709548746LLU; // 99999999SJ'''''''''''''''
47289+ state.addr = 18446744073709548793LLU; // 99999999S3'''''''''''''''
4806347290 break;
4806447291 }
48065- case 18446744073709548746LLU: // 99999999SJ'''''''''''''''
47292+ case 18446744073709548793LLU: // 99999999S3'''''''''''''''
4806647293 {
4806747294 fprintf(stdout, "%s", ")");
48068- state.addr = 18446744073709548753LLU; // 99999999SQ'''''''''''''''
47295+ state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
4806947296 break;
4807047297 }
48071- case 18446744073709548753LLU: // 99999999SQ'''''''''''''''
47298+ case 18446744073709548800LLU: // 99999999T_'''''''''''''''
4807247299 {
4807347300 // variable u64 called____ goes out of scope
4807447301 // emitted destructur for type u64
@@ -48078,10 +47305,10 @@
4807847305 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference argid_____ at 25
4807947306 heap.availilable_size_for_dynamic_objects += 0LLU;
4808047307 heap.availilable_size_for_dynamic_objects += 0LLU;
48081- state.addr = 18446744073709548744LLU; // 99999999SH'''''''''''''''
47308+ state.addr = 18446744073709548791LLU; // 99999999S1'''''''''''''''
4808247309 break;
4808347310 }
48084- case 18446744073709548775LLU: // 99999999Sl'''''''''''''''
47311+ case 18446744073709548822LLU: // 99999999TV'''''''''''''''
4808547312 {
4808647313 {
4808747314 uint64_t arg = 0LLU;
@@ -48095,7 +47322,7 @@
4809547322 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4809647323 }
4809747324 // ACCUMULATE ARGUMENTS - END
48098- uint64_t return_to = 18446744073709548742LLU;
47325+ uint64_t return_to = 18446744073709548789LLU;
4809947326 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4810047327 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4810147328 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48104,12 +47331,12 @@
4810447331 state.addr = 660197403663532032LLU; // indent____
4810547332 break;
4810647333 }
48107- case 18446744073709548742LLU: // 99999999SF'''''''''''''''
47334+ case 18446744073709548789LLU: // 99999999Sz'''''''''''''''
4810847335 {
48109- state.addr = 18446744073709548743LLU; // 99999999SG'''''''''''''''
47336+ state.addr = 18446744073709548790LLU; // 99999999S0'''''''''''''''
4811047337 break;
4811147338 }
48112- case 18446744073709548743LLU: // 99999999SG'''''''''''''''
47339+ case 18446744073709548790LLU: // 99999999S0'''''''''''''''
4811347340 {
4811447341 fprintf(stdout, "%s", " {");
4811547342 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48118,7 +47345,7 @@
4811847345 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4811947346 }
4812047347 // ACCUMULATE ARGUMENTS - END
48121- uint64_t return_to = 18446744073709548740LLU;
47348+ uint64_t return_to = 18446744073709548787LLU;
4812247349 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4812347350 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4812447351 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48127,12 +47354,12 @@
4812747354 state.addr = 660197403663532032LLU; // indent____
4812847355 break;
4812947356 }
48130- case 18446744073709548740LLU: // 99999999SD'''''''''''''''
47357+ case 18446744073709548787LLU: // 99999999Sx'''''''''''''''
4813147358 {
48132- state.addr = 18446744073709548741LLU; // 99999999SE'''''''''''''''
47359+ state.addr = 18446744073709548788LLU; // 99999999Sy'''''''''''''''
4813347360 break;
4813447361 }
48135- case 18446744073709548741LLU: // 99999999SE'''''''''''''''
47362+ case 18446744073709548788LLU: // 99999999Sy'''''''''''''''
4813647363 {
4813747364 fprintf(stdout, "%s", " uint64_t value = ");
4813847365 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48141,7 +47368,7 @@
4814147368 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4814247369 }
4814347370 // ACCUMULATE ARGUMENTS - END
48144- uint64_t return_to = 18446744073709548738LLU;
47371+ uint64_t return_to = 18446744073709548785LLU;
4814547372 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4814647373 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4814747374 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48150,12 +47377,12 @@
4815047377 state.addr = 787446708198178816LLU; // printnr___
4815147378 break;
4815247379 }
48153- case 18446744073709548738LLU: // 99999999SB'''''''''''''''
47380+ case 18446744073709548785LLU: // 99999999Sv'''''''''''''''
4815447381 {
48155- state.addr = 18446744073709548739LLU; // 99999999SC'''''''''''''''
47382+ state.addr = 18446744073709548786LLU; // 99999999Sw'''''''''''''''
4815647383 break;
4815747384 }
48158- case 18446744073709548739LLU: // 99999999SC'''''''''''''''
47385+ case 18446744073709548786LLU: // 99999999Sw'''''''''''''''
4815947386 {
4816047387 fprintf(stdout, "%s", ";");
4816147388 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48164,7 +47391,7 @@
4816447391 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4816547392 }
4816647393 // ACCUMULATE ARGUMENTS - END
48167- uint64_t return_to = 18446744073709548736LLU;
47394+ uint64_t return_to = 18446744073709548783LLU;
4816847395 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4816947396 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4817047397 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48173,12 +47400,12 @@
4817347400 state.addr = 660197403663532032LLU; // indent____
4817447401 break;
4817547402 }
48176- case 18446744073709548736LLU: // 99999999S_'''''''''''''''
47403+ case 18446744073709548783LLU: // 99999999St'''''''''''''''
4817747404 {
48178- state.addr = 18446744073709548737LLU; // 99999999SA'''''''''''''''
47405+ state.addr = 18446744073709548784LLU; // 99999999Su'''''''''''''''
4817947406 break;
4818047407 }
48181- case 18446744073709548737LLU: // 99999999SA'''''''''''''''
47408+ case 18446744073709548784LLU: // 99999999Su'''''''''''''''
4818247409 {
4818347410 fprintf(stdout, "%s", " tree_push_move(&heap, ");
4818447411 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48187,7 +47414,7 @@
4818747414 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4818847415 }
4818947416 // ACCUMULATE ARGUMENTS - END
48190- uint64_t return_to = 18446744073709548734LLU;
47417+ uint64_t return_to = 18446744073709548781LLU;
4819147418 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4819247419 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4819347420 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48196,12 +47423,12 @@
4819647423 state.addr = 787446708198178816LLU; // printnr___
4819747424 break;
4819847425 }
48199- case 18446744073709548734LLU: // 99999999R8'''''''''''''''
47426+ case 18446744073709548781LLU: // 99999999Sr'''''''''''''''
4820047427 {
48201- state.addr = 18446744073709548735LLU; // 99999999R9'''''''''''''''
47428+ state.addr = 18446744073709548782LLU; // 99999999Ss'''''''''''''''
4820247429 break;
4820347430 }
48204- case 18446744073709548735LLU: // 99999999R9'''''''''''''''
47431+ case 18446744073709548782LLU: // 99999999Ss'''''''''''''''
4820547432 {
4820647433 fprintf(stdout, "%s", ", &arg");
4820747434 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48210,7 +47437,7 @@
4821047437 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4821147438 }
4821247439 // ACCUMULATE ARGUMENTS - END
48213- uint64_t return_to = 18446744073709548732LLU;
47440+ uint64_t return_to = 18446744073709548779LLU;
4821447441 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4821547442 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4821647443 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48219,12 +47446,12 @@
4821947446 state.addr = 787446708200409962LLU; // printnzero
4822047447 break;
4822147448 }
48222- case 18446744073709548732LLU: // 99999999R6'''''''''''''''
47449+ case 18446744073709548779LLU: // 99999999Sp'''''''''''''''
4822347450 {
48224- state.addr = 18446744073709548733LLU; // 99999999R7'''''''''''''''
47451+ state.addr = 18446744073709548780LLU; // 99999999Sq'''''''''''''''
4822547452 break;
4822647453 }
48227- case 18446744073709548733LLU: // 99999999R7'''''''''''''''
47454+ case 18446744073709548780LLU: // 99999999Sq'''''''''''''''
4822847455 {
4822947456 fprintf(stdout, "%s", ", &value");
4823047457 fprintf(stdout, "%s", ");");
@@ -48234,7 +47461,7 @@
4823447461 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4823547462 }
4823647463 // ACCUMULATE ARGUMENTS - END
48237- uint64_t return_to = 18446744073709548730LLU;
47464+ uint64_t return_to = 18446744073709548777LLU;
4823847465 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4823947466 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4824047467 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48243,21 +47470,21 @@
4824347470 state.addr = 660197403663532032LLU; // indent____
4824447471 break;
4824547472 }
48246- case 18446744073709548730LLU: // 99999999R4'''''''''''''''
47473+ case 18446744073709548777LLU: // 99999999Sn'''''''''''''''
4824747474 {
48248- state.addr = 18446744073709548731LLU; // 99999999R5'''''''''''''''
47475+ state.addr = 18446744073709548778LLU; // 99999999So'''''''''''''''
4824947476 break;
4825047477 }
48251- case 18446744073709548731LLU: // 99999999R5'''''''''''''''
47478+ case 18446744073709548778LLU: // 99999999So'''''''''''''''
4825247479 {
4825347480 fprintf(stdout, "%s", " }");
4825447481 // variable u64 nr________ goes out of scope
4825547482 // emitted destructur for type u64
4825647483 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 25
48257- state.addr = 18446744073709548744LLU; // 99999999SH'''''''''''''''
47484+ state.addr = 18446744073709548791LLU; // 99999999S1'''''''''''''''
4825847485 break;
4825947486 }
48260- case 18446744073709548744LLU: // 99999999SH'''''''''''''''
47487+ case 18446744073709548791LLU: // 99999999S1'''''''''''''''
4826147488 {
4826247489 // variable u64 matchsym__ goes out of scope
4826347490 // emitted destructur for type u64
@@ -48265,35 +47492,35 @@
4826547492 // variable u64 sym_______ goes out of scope
4826647493 // emitted destructur for type u64
4826747494 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 23
48268- state.addr = 18446744073709548781LLU; // 99999999Sr'''''''''''''''
47495+ state.addr = 18446744073709548828LLU; // 99999999Ta'''''''''''''''
4826947496 break;
4827047497 }
48271- case 18446744073709548781LLU: // 99999999Sr'''''''''''''''
47498+ case 18446744073709548828LLU: // 99999999Ta'''''''''''''''
4827247499 {
4827347500 ++/*paridx____*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
4827447501 // parameter-reference pardef____ elem______ goes out of scope
4827547502 // parameter list<pardef____> elems_____ goes out of scope
48276- state.addr = 18446744073709548787LLU; // 99999999Sx'''''''''''''''
47503+ state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
4827747504 break;
4827847505 }
48279- case 18446744073709548786LLU: // 99999999Sw'''''''''''''''
47506+ case 18446744073709548833LLU: // 99999999Tf'''''''''''''''
4828047507 {
4828147508 // variable u64 paridx____ goes out of scope
4828247509 // emitted destructur for type u64
4828347510 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference paridx____ at 20
48284- state.addr = 18446744073709548813LLU; // 99999999TM'''''''''''''''
47511+ state.addr = 18446744073709548860LLU; // 99999999T6'''''''''''''''
4828547512 break;
4828647513 }
48287- case 18446744073709548813LLU: // 99999999TM'''''''''''''''
47514+ case 18446744073709548860LLU: // 99999999T6'''''''''''''''
4828847515 {
4828947516 // parameter-reference u64 SIZEONHEAP goes out of scope
4829047517 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference SIZEONHEAP at 19
4829147518 // parameter-reference typekind__ kind______ goes out of scope
4829247519 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference kind______ at 18
48293- state.addr = 18446744073709548902LLU; // 99999999Uk'''''''''''''''
47520+ state.addr = 18446744073709548949LLU; // 99999999VU'''''''''''''''
4829447521 break;
4829547522 }
48296- case 18446744073709548902LLU: // 99999999Uk'''''''''''''''
47523+ case 18446744073709548949LLU: // 99999999VU'''''''''''''''
4829747524 {
4829847525 // variable typedef___ def_______ goes out of scope
4829947526 // emitted destructur for type typedef___
@@ -48303,7 +47530,7 @@
4830347530 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4830447531 }
4830547532 // ACCUMULATE ARGUMENTS - END
48306- uint64_t return_to = 18446744073709548729LLU;
47533+ uint64_t return_to = 18446744073709548776LLU;
4830747534 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4830847535 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4830947536 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48312,7 +47539,7 @@
4831247539 state.addr = 18446744073709551111LLU; // 999999992G'''''''''''''''
4831347540 break;
4831447541 }
48315- case 18446744073709548729LLU: // 99999999R3'''''''''''''''
47542+ case 18446744073709548776LLU: // 99999999Sm'''''''''''''''
4831647543 {
4831747544 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_______ at 17
4831847545 // variable u64 calleeacnt goes out of scope
@@ -48323,14 +47550,14 @@
4832347550 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference calleesize at 15
4832447551 // variable list<pardef____> elems_____ goes out of scope
4832547552 // emitted destructur for type list<pardef____>
48326- state.addr = 18446744073709548727LLU; // 99999999R1'''''''''''''''
47553+ state.addr = 18446744073709548774LLU; // 99999999Sk'''''''''''''''
4832747554 break;
4832847555 }
48329- case 18446744073709548727LLU: // 99999999R1'''''''''''''''
47556+ case 18446744073709548774LLU: // 99999999Sk'''''''''''''''
4833047557 {
4833147558 if(!*LOCAL_ACCESS(heap.data, 14LLU, 13LLU)/*list*/)
4833247559 {
48333- state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
47560+ state.addr = 18446744073709548775LLU; // 99999999Sl'''''''''''''''
4833447561 break;
4833547562 }
4833647563 // temporary list-element
@@ -48344,7 +47571,7 @@
4834447571 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4834547572 }
4834647573 // ACCUMULATE ARGUMENTS - END
48347- uint64_t return_to = 18446744073709548726LLU;
47574+ uint64_t return_to = 18446744073709548773LLU;
4834847575 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4834947576 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4835047577 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48353,14 +47580,14 @@
4835347580 state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
4835447581 break;
4835547582 }
48356- case 18446744073709548726LLU: // 99999999R0'''''''''''''''
47583+ case 18446744073709548773LLU: // 99999999Sj'''''''''''''''
4835747584 {
4835847585 // RELEASE temporary destructor-variable
4835947586 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 15
48360- state.addr = 18446744073709548727LLU; // 99999999R1'''''''''''''''
47587+ state.addr = 18446744073709548774LLU; // 99999999Sk'''''''''''''''
4836147588 break;
4836247589 }
48363- case 18446744073709548728LLU: // 99999999R2'''''''''''''''
47590+ case 18446744073709548775LLU: // 99999999Sl'''''''''''''''
4836447591 {
4836547592 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference elems_____ at 14
4836647593 // parameter-reference u64 maintype__ goes out of scope
@@ -48367,10 +47594,10 @@
4836747594 (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 13
4836847595 heap.availilable_size_for_dynamic_objects += 0LLU;
4836947596 heap.availilable_size_for_dynamic_objects += 0LLU;
48370- state.addr = 18446744073709548725LLU; // 99999999Rz'''''''''''''''
47597+ state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
4837147598 break;
4837247599 }
48373- case 18446744073709548906LLU: // 99999999Uo'''''''''''''''
47600+ case 18446744073709548953LLU: // 99999999VY'''''''''''''''
4837447601 {
4837547602 // ACCUMULATE ARGUMENTS - BEGIN
4837647603 {
@@ -48378,7 +47605,7 @@
4837847605 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4837947606 }
4838047607 // ACCUMULATE ARGUMENTS - END
48381- uint64_t return_to = 18446744073709548723LLU;
47608+ uint64_t return_to = 18446744073709548770LLU;
4838247609 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4838347610 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4838447611 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48387,12 +47614,12 @@
4838747614 state.addr = 819847183515949359LLU; // reportinit
4838847615 break;
4838947616 }
48390- case 18446744073709548723LLU: // 99999999Rx'''''''''''''''
47617+ case 18446744073709548770LLU: // 99999999Sg'''''''''''''''
4839147618 {
48392- state.addr = 18446744073709548724LLU; // 99999999Ry'''''''''''''''
47619+ state.addr = 18446744073709548771LLU; // 99999999Sh'''''''''''''''
4839347620 break;
4839447621 }
48395- case 18446744073709548724LLU: // 99999999Ry'''''''''''''''
47622+ case 18446744073709548771LLU: // 99999999Sh'''''''''''''''
4839647623 {
4839747624 fprintf(stderr, "%s", "type ");
4839847625 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48401,7 +47628,7 @@
4840147628 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4840247629 }
4840347630 // ACCUMULATE ARGUMENTS - END
48404- uint64_t return_to = 18446744073709548721LLU;
47631+ uint64_t return_to = 18446744073709548768LLU;
4840547632 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4840647633 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4840747634 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48410,12 +47637,12 @@
4841047637 state.addr = 819847183518878432LLU; // reporttype
4841147638 break;
4841247639 }
48413- case 18446744073709548721LLU: // 99999999Rv'''''''''''''''
47640+ case 18446744073709548768LLU: // 99999999Se'''''''''''''''
4841447641 {
48415- state.addr = 18446744073709548722LLU; // 99999999Rw'''''''''''''''
47642+ state.addr = 18446744073709548769LLU; // 99999999Sf'''''''''''''''
4841647643 break;
4841747644 }
48418- case 18446744073709548722LLU: // 99999999Rw'''''''''''''''
47645+ case 18446744073709548769LLU: // 99999999Sf'''''''''''''''
4841947646 {
4842047647 fprintf(stderr, "%s", " can only be constructed by literals");
4842147648 {
@@ -48422,10 +47649,10 @@
4842247649 fprintf(stderr, "%s\n", "");
4842347650 exit(-1);
4842447651 }
48425- state.addr = 18446744073709548725LLU; // 99999999Rz'''''''''''''''
47652+ state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
4842647653 break;
4842747654 }
48428- case 18446744073709548725LLU: // 99999999Rz'''''''''''''''
47655+ case 18446744073709548772LLU: // 99999999Si'''''''''''''''
4842947656 {
4843047657 // parameter-reference u64 remainsize goes out of scope
4843147658 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainsize at 12
@@ -48473,10 +47700,10 @@
4847347700 };
4847447701 *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = arg;
4847547702 }
48476- state.addr = 18446744073709548720LLU; // 99999999Ru'''''''''''''''
47703+ state.addr = 18446744073709548767LLU; // 99999999Sd'''''''''''''''
4847747704 break;
4847847705 }
48479- case 18446744073709548720LLU: // 99999999Ru'''''''''''''''
47706+ case 18446744073709548767LLU: // 99999999Sd'''''''''''''''
4848047707 {
4848147708 {
4848247709 uint64_t arg = 0LLU;
@@ -48556,7 +47783,7 @@
4855647783 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4855747784 }
4855847785 // ACCUMULATE ARGUMENTS - END
48559- uint64_t return_to = 18446744073709548716LLU;
47786+ uint64_t return_to = 18446744073709548763LLU;
4856047787 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
4856147788 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4856247789 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48565,12 +47792,12 @@
4856547792 state.addr = 604790753280317473LLU; // findvarref
4856647793 break;
4856747794 }
48568- case 18446744073709548716LLU: // 99999999Rq'''''''''''''''
47795+ case 18446744073709548763LLU: // 99999999S$'''''''''''''''
4856947796 {
48570- state.addr = 18446744073709548717LLU; // 99999999Rr'''''''''''''''
47797+ state.addr = 18446744073709548764LLU; // 99999999Sa'''''''''''''''
4857147798 break;
4857247799 }
48573- case 18446744073709548717LLU: // 99999999Rr'''''''''''''''
47800+ case 18446744073709548764LLU: // 99999999Sa'''''''''''''''
4857447801 {
4857547802 // variable u64 consume___ goes out of scope
4857647803 // emitted destructur for type u64
@@ -48578,25 +47805,25 @@
4857847805 // variable u64 optelem___ goes out of scope
4857947806 // emitted destructur for type u64
4858047807 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 20
48581- state.addr = 18446744073709548718LLU; // 99999999Rs'''''''''''''''
47808+ state.addr = 18446744073709548765LLU; // 99999999Sb'''''''''''''''
4858247809 break;
4858347810 }
48584- case 18446744073709548718LLU: // 99999999Rs'''''''''''''''
47811+ case 18446744073709548765LLU: // 99999999Sb'''''''''''''''
4858547812 {
48586- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548715LLU : 18446744073709548714LLU;
47813+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548762LLU : 18446744073709548761LLU;
4858747814 break;
4858847815 }
48589- case 18446744073709548715LLU: // 99999999Rp'''''''''''''''
47816+ case 18446744073709548762LLU: // 99999999SZ'''''''''''''''
4859047817 {
48591- state.addr = /*mutable___*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548713LLU : 18446744073709548712LLU;
47818+ state.addr = /*mutable___*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548760LLU : 18446744073709548759LLU;
4859247819 break;
4859347820 }
48594- case 18446744073709548713LLU: // 99999999Rn'''''''''''''''
47821+ case 18446744073709548760LLU: // 99999999SX'''''''''''''''
4859547822 {
48596- state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548711LLU : 18446744073709548710LLU;
47823+ state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548758LLU : 18446744073709548757LLU;
4859747824 break;
4859847825 }
48599- case 18446744073709548711LLU: // 99999999Rl'''''''''''''''
47826+ case 18446744073709548758LLU: // 99999999SV'''''''''''''''
4860047827 {
4860147828 {
4860247829 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, LOCAL_ACCESS_ADDR(heap.data, 19LLU, 13LLU), 1/*content*/), 0LLU);
@@ -48619,10 +47846,10 @@
4861947846 };
4862047847 *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = arg;
4862147848 }
48622- state.addr = 18446744073709548709LLU; // 99999999Rj'''''''''''''''
47849+ state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
4862347850 break;
4862447851 }
48625- case 18446744073709548709LLU: // 99999999Rj'''''''''''''''
47852+ case 18446744073709548756LLU: // 99999999ST'''''''''''''''
4862647853 {
4862747854 // ACCUMULATE ARGUMENTS - BEGIN
4862847855 {
@@ -48662,7 +47889,7 @@
4866247889 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4866347890 }
4866447891 // ACCUMULATE ARGUMENTS - END
48665- uint64_t return_to = 18446744073709548707LLU;
47892+ uint64_t return_to = 18446744073709548754LLU;
4866647893 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0));
4866747894 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4866847895 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48671,12 +47898,12 @@
4867147898 state.addr = 587881344696777536LLU; // emitdestr_
4867247899 break;
4867347900 }
48674- case 18446744073709548707LLU: // 99999999Rh'''''''''''''''
47901+ case 18446744073709548754LLU: // 99999999SR'''''''''''''''
4867547902 {
48676- state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
47903+ state.addr = 18446744073709548755LLU; // 99999999SS'''''''''''''''
4867747904 break;
4867847905 }
48679- case 18446744073709548708LLU: // 99999999Ri'''''''''''''''
47906+ case 18446744073709548755LLU: // 99999999SS'''''''''''''''
4868047907 {
4868147908 // variable type______ TYPEDST___ goes out of scope
4868247909 // emitted destructur for type type______
@@ -48686,7 +47913,7 @@
4868647913 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4868747914 }
4868847915 // ACCUMULATE ARGUMENTS - END
48689- uint64_t return_to = 18446744073709548706LLU;
47916+ uint64_t return_to = 18446744073709548753LLU;
4869047917 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4869147918 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4869247919 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48695,7 +47922,7 @@
4869547922 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
4869647923 break;
4869747924 }
48698- case 18446744073709548706LLU: // 99999999Rg'''''''''''''''
47925+ case 18446744073709548753LLU: // 99999999SQ'''''''''''''''
4869947926 {
4870047927 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPEDST___ at 22
4870147928 // variable u64 name______ goes out of scope
@@ -48705,22 +47932,22 @@
4870547932 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 20
4870647933 heap.availilable_size_for_dynamic_objects += 0LLU;
4870747934 heap.availilable_size_for_dynamic_objects += 0LLU;
48708- state.addr = 18446744073709548705LLU; // 99999999Rf'''''''''''''''
47935+ state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
4870947936 break;
4871047937 }
48711- case 18446744073709548710LLU: // 99999999Rk'''''''''''''''
47938+ case 18446744073709548757LLU: // 99999999SU'''''''''''''''
4871247939 {
48713- state.addr = 18446744073709548705LLU; // 99999999Rf'''''''''''''''
47940+ state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
4871447941 break;
4871547942 }
48716- case 18446744073709548705LLU: // 99999999Rf'''''''''''''''
47943+ case 18446744073709548752LLU: // 99999999SP'''''''''''''''
4871747944 {
4871847945 heap.availilable_size_for_dynamic_objects += 0LLU;
4871947946 heap.availilable_size_for_dynamic_objects += 0LLU;
48720- state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
47947+ state.addr = 18446744073709548751LLU; // 99999999SO'''''''''''''''
4872147948 break;
4872247949 }
48723- case 18446744073709548712LLU: // 99999999Rm'''''''''''''''
47950+ case 18446744073709548759LLU: // 99999999SW'''''''''''''''
4872447951 {
4872547952 fprintf(stderr, "%s", "cannot assign to constant ");
4872647953 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48729,7 +47956,7 @@
4872947956 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4873047957 }
4873147958 // ACCUMULATE ARGUMENTS - END
48732- uint64_t return_to = 18446744073709548702LLU;
47959+ uint64_t return_to = 18446744073709548749LLU;
4873347960 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4873447961 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4873547962 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48738,12 +47965,12 @@
4873847965 state.addr = 819847183518878432LLU; // reporttype
4873947966 break;
4874047967 }
48741- case 18446744073709548702LLU: // 99999999Rc'''''''''''''''
47968+ case 18446744073709548749LLU: // 99999999SM'''''''''''''''
4874247969 {
48743- state.addr = 18446744073709548703LLU; // 99999999Rd'''''''''''''''
47970+ state.addr = 18446744073709548750LLU; // 99999999SN'''''''''''''''
4874447971 break;
4874547972 }
48746- case 18446744073709548703LLU: // 99999999Rd'''''''''''''''
47973+ case 18446744073709548750LLU: // 99999999SN'''''''''''''''
4874747974 {
4874847975 fprintf(stderr, "%s", " ");
4874947976 printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
@@ -48751,17 +47978,17 @@
4875147978 fprintf(stderr, "%s\n", "");
4875247979 exit(-1);
4875347980 }
48754- state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
47981+ state.addr = 18446744073709548751LLU; // 99999999SO'''''''''''''''
4875547982 break;
4875647983 }
48757- case 18446744073709548704LLU: // 99999999Re'''''''''''''''
47984+ case 18446744073709548751LLU: // 99999999SO'''''''''''''''
4875847985 {
4875947986 heap.availilable_size_for_dynamic_objects += 0LLU;
4876047987 heap.availilable_size_for_dynamic_objects += 0LLU;
48761- state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
47988+ state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
4876247989 break;
4876347990 }
48764- case 18446744073709548714LLU: // 99999999Ro'''''''''''''''
47991+ case 18446744073709548761LLU: // 99999999SY'''''''''''''''
4876547992 {
4876647993 // ACCUMULATE ARGUMENTS - BEGIN
4876747994 {
@@ -48781,7 +48008,7 @@
4878148008 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4878248009 }
4878348010 // ACCUMULATE ARGUMENTS - END
48784- uint64_t return_to = 18446744073709548699LLU;
48011+ uint64_t return_to = 18446744073709548746LLU;
4878548012 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4878648013 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4878748014 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48790,17 +48017,17 @@
4879048017 state.addr = 660220432971388961LLU; // initvarref
4879148018 break;
4879248019 }
48793- case 18446744073709548699LLU: // 99999999R$'''''''''''''''
48020+ case 18446744073709548746LLU: // 99999999SJ'''''''''''''''
4879448021 {
48795- state.addr = 18446744073709548700LLU; // 99999999Ra'''''''''''''''
48022+ state.addr = 18446744073709548747LLU; // 99999999SK'''''''''''''''
4879648023 break;
4879748024 }
48798- case 18446744073709548700LLU: // 99999999Ra'''''''''''''''
48025+ case 18446744073709548747LLU: // 99999999SK'''''''''''''''
4879948026 {
48800- state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
48027+ state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
4880148028 break;
4880248029 }
48803- case 18446744073709548701LLU: // 99999999Rb'''''''''''''''
48030+ case 18446744073709548748LLU: // 99999999SL'''''''''''''''
4880448031 {
4880548032 // variable u64 parameter_ goes out of scope
4880648033 // emitted destructur for type u64
@@ -48808,10 +48035,10 @@
4880848035 // variable u64 mutable___ goes out of scope
4880948036 // emitted destructur for type u64
4881048037 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 18
48811- state.addr = 18446744073709548719LLU; // 99999999Rt'''''''''''''''
48038+ state.addr = 18446744073709548766LLU; // 99999999Sc'''''''''''''''
4881248039 break;
4881348040 }
48814- case 18446744073709548719LLU: // 99999999Rt'''''''''''''''
48041+ case 18446744073709548766LLU: // 99999999Sc'''''''''''''''
4881548042 {
4881648043 // ACCUMULATE ARGUMENTS - BEGIN
4881748044 {
@@ -48819,7 +48046,7 @@
4881948046 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4882048047 }
4882148048 // ACCUMULATE ARGUMENTS - END
48822- uint64_t return_to = 18446744073709548697LLU;
48049+ uint64_t return_to = 18446744073709548744LLU;
4882348050 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4882448051 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4882548052 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48828,12 +48055,12 @@
4882848055 state.addr = 839519719621918720LLU; // skipws____
4882948056 break;
4883048057 }
48831- case 18446744073709548697LLU: // 99999999RY'''''''''''''''
48058+ case 18446744073709548744LLU: // 99999999SH'''''''''''''''
4883248059 {
48833- state.addr = 18446744073709548698LLU; // 99999999RZ'''''''''''''''
48060+ state.addr = 18446744073709548745LLU; // 99999999SI'''''''''''''''
4883448061 break;
4883548062 }
48836- case 18446744073709548698LLU: // 99999999RZ'''''''''''''''
48063+ case 18446744073709548745LLU: // 99999999SI'''''''''''''''
4883748064 {
4883848065 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 8LLU)));
4883948066 {
@@ -48846,7 +48073,7 @@
4884648073 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4884748074 }
4884848075 // ACCUMULATE ARGUMENTS - END
48849- uint64_t return_to = 18446744073709548695LLU;
48076+ uint64_t return_to = 18446744073709548742LLU;
4885048077 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4885148078 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4885248079 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48855,12 +48082,12 @@
4885548082 state.addr = 839519719621918720LLU; // skipws____
4885648083 break;
4885748084 }
48858- case 18446744073709548695LLU: // 99999999RW'''''''''''''''
48085+ case 18446744073709548742LLU: // 99999999SF'''''''''''''''
4885948086 {
48860- state.addr = 18446744073709548696LLU; // 99999999RX'''''''''''''''
48087+ state.addr = 18446744073709548743LLU; // 99999999SG'''''''''''''''
4886148088 break;
4886248089 }
48863- case 18446744073709548696LLU: // 99999999RX'''''''''''''''
48090+ case 18446744073709548743LLU: // 99999999SG'''''''''''''''
4886448091 {
4886548092 {
4886648093 uint64_t arg = 59LLU;
@@ -48884,7 +48111,7 @@
4888448111 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4888548112 }
4888648113 // ACCUMULATE ARGUMENTS - END
48887- uint64_t return_to = 18446744073709548693LLU;
48114+ uint64_t return_to = 18446744073709548740LLU;
4888848115 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4888948116 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4889048117 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48893,17 +48120,17 @@
4889348120 state.addr = 728666047794575267LLU; // matchoptch
4889448121 break;
4889548122 }
48896- case 18446744073709548693LLU: // 99999999RU'''''''''''''''
48123+ case 18446744073709548740LLU: // 99999999SD'''''''''''''''
4889748124 {
48898- state.addr = 18446744073709548694LLU; // 99999999RV'''''''''''''''
48125+ state.addr = 18446744073709548741LLU; // 99999999SE'''''''''''''''
4889948126 break;
4890048127 }
48901- case 18446744073709548694LLU: // 99999999RV'''''''''''''''
48128+ case 18446744073709548741LLU: // 99999999SE'''''''''''''''
4890248129 {
48903- state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548692LLU : 18446744073709548691LLU;
48130+ state.addr = /*match_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548739LLU : 18446744073709548738LLU;
4890448131 break;
4890548132 }
48906- case 18446744073709548692LLU: // 99999999RT'''''''''''''''
48133+ case 18446744073709548739LLU: // 99999999SC'''''''''''''''
4890748134 {
4890848135 // ACCUMULATE ARGUMENTS - BEGIN
4890948136 {
@@ -48915,7 +48142,7 @@
4891548142 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4891648143 }
4891748144 // ACCUMULATE ARGUMENTS - END
48918- uint64_t return_to = 18446744073709548689LLU;
48145+ uint64_t return_to = 18446744073709548736LLU;
4891948146 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4892048147 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4892148148 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48924,17 +48151,17 @@
4892448151 state.addr = 517555565476695680LLU; // assertu64_
4892548152 break;
4892648153 }
48927- case 18446744073709548689LLU: // 99999999RQ'''''''''''''''
48154+ case 18446744073709548736LLU: // 99999999S_'''''''''''''''
4892848155 {
48929- state.addr = 18446744073709548690LLU; // 99999999RR'''''''''''''''
48156+ state.addr = 18446744073709548737LLU; // 99999999SA'''''''''''''''
4893048157 break;
4893148158 }
48932- case 18446744073709548690LLU: // 99999999RR'''''''''''''''
48159+ case 18446744073709548737LLU: // 99999999SA'''''''''''''''
4893348160 {
48934- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548688LLU : 18446744073709548687LLU;
48161+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548735LLU : 18446744073709548734LLU;
4893548162 break;
4893648163 }
48937- case 18446744073709548688LLU: // 99999999RP'''''''''''''''
48164+ case 18446744073709548735LLU: // 99999999R9'''''''''''''''
4893848165 {
4893948166 fprintf(stdout, "%s", "\n ");
4894048167 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48959,7 +48186,7 @@
4895948186 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4896048187 }
4896148188 // ACCUMULATE ARGUMENTS - END
48962- uint64_t return_to = 18446744073709548685LLU;
48189+ uint64_t return_to = 18446744073709548732LLU;
4896348190 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4896448191 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4896548192 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -48968,12 +48195,12 @@
4896848195 state.addr = 587881357514113024LLU; // emitpar___
4896948196 break;
4897048197 }
48971- case 18446744073709548685LLU: // 99999999RM'''''''''''''''
48198+ case 18446744073709548732LLU: // 99999999R6'''''''''''''''
4897248199 {
48973- state.addr = 18446744073709548686LLU; // 99999999RN'''''''''''''''
48200+ state.addr = 18446744073709548733LLU; // 99999999R7'''''''''''''''
4897448201 break;
4897548202 }
48976- case 18446744073709548686LLU: // 99999999RN'''''''''''''''
48203+ case 18446744073709548733LLU: // 99999999R7'''''''''''''''
4897748204 {
4897848205 fprintf(stdout, "%s", " = 0;");
4897948206 // ACCUMULATE ARGUMENTS - BEGIN
@@ -48994,7 +48221,7 @@
4899448221 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4899548222 }
4899648223 // ACCUMULATE ARGUMENTS - END
48997- uint64_t return_to = 18446744073709548683LLU;
48224+ uint64_t return_to = 18446744073709548730LLU;
4899848225 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4899948226 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4900048227 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49003,31 +48230,31 @@
4900348230 state.addr = 732615645798520865LLU; // movevarref
4900448231 break;
4900548232 }
49006- case 18446744073709548683LLU: // 99999999RK'''''''''''''''
48233+ case 18446744073709548730LLU: // 99999999R4'''''''''''''''
4900748234 {
49008- state.addr = 18446744073709548684LLU; // 99999999RL'''''''''''''''
48235+ state.addr = 18446744073709548731LLU; // 99999999R5'''''''''''''''
4900948236 break;
4901048237 }
49011- case 18446744073709548684LLU: // 99999999RL'''''''''''''''
48238+ case 18446744073709548731LLU: // 99999999R5'''''''''''''''
4901248239 {
4901348240 heap.availilable_size_for_dynamic_objects += 0LLU;
4901448241 heap.availilable_size_for_dynamic_objects += 0LLU;
49015- state.addr = 18446744073709548682LLU; // 99999999RJ'''''''''''''''
48242+ state.addr = 18446744073709548729LLU; // 99999999R3'''''''''''''''
4901648243 break;
4901748244 }
49018- case 18446744073709548687LLU: // 99999999RO'''''''''''''''
48245+ case 18446744073709548734LLU: // 99999999R8'''''''''''''''
4901948246 {
49020- state.addr = 18446744073709548682LLU; // 99999999RJ'''''''''''''''
48247+ state.addr = 18446744073709548729LLU; // 99999999R3'''''''''''''''
4902148248 break;
4902248249 }
49023- case 18446744073709548682LLU: // 99999999RJ'''''''''''''''
48250+ case 18446744073709548729LLU: // 99999999R3'''''''''''''''
4902448251 {
4902548252 heap.availilable_size_for_dynamic_objects += 0LLU;
4902648253 heap.availilable_size_for_dynamic_objects += 0LLU;
49027- state.addr = 18446744073709548681LLU; // 99999999RI'''''''''''''''
48254+ state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
4902848255 break;
4902948256 }
49030- case 18446744073709548691LLU: // 99999999RS'''''''''''''''
48257+ case 18446744073709548738LLU: // 99999999SB'''''''''''''''
4903148258 {
4903248259 // ACCUMULATE ARGUMENTS - BEGIN
4903348260 {
@@ -49039,7 +48266,7 @@
4903948266 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4904048267 }
4904148268 // ACCUMULATE ARGUMENTS - END
49042- uint64_t return_to = 18446744073709548679LLU;
48269+ uint64_t return_to = 18446744073709548726LLU;
4904348270 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4904448271 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4904548272 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49048,22 +48275,22 @@
4904848275 state.addr = 661605045736570880LLU; // isdigit___
4904948276 break;
4905048277 }
49051- case 18446744073709548679LLU: // 99999999RG'''''''''''''''
48278+ case 18446744073709548726LLU: // 99999999R0'''''''''''''''
4905248279 {
49053- state.addr = 18446744073709548680LLU; // 99999999RH'''''''''''''''
48280+ state.addr = 18446744073709548727LLU; // 99999999R1'''''''''''''''
4905448281 break;
4905548282 }
49056- case 18446744073709548680LLU: // 99999999RH'''''''''''''''
48283+ case 18446744073709548727LLU: // 99999999R1'''''''''''''''
4905748284 {
49058- state.addr = /*nrconst___*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548678LLU : 18446744073709548677LLU;
48285+ state.addr = /*nrconst___*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548725LLU : 18446744073709548724LLU;
4905948286 break;
4906048287 }
49061- case 18446744073709548678LLU: // 99999999RF'''''''''''''''
48288+ case 18446744073709548725LLU: // 99999999Rz'''''''''''''''
4906248289 {
49063- state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 20LLU, 13LLU)].elem0 ? 18446744073709548676LLU : 18446744073709548675LLU;
48290+ state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 20LLU, 13LLU)].elem0 ? 18446744073709548723LLU : 18446744073709548722LLU;
4906448291 break;
4906548292 }
49066- case 18446744073709548676LLU: // 99999999RD'''''''''''''''
48293+ case 18446744073709548723LLU: // 99999999Rx'''''''''''''''
4906748294 {
4906848295 // ACCUMULATE ARGUMENTS - BEGIN
4906948296 {
@@ -49087,7 +48314,7 @@
4908748314 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4908848315 }
4908948316 // ACCUMULATE ARGUMENTS - END
49090- uint64_t return_to = 18446744073709548673LLU;
48317+ uint64_t return_to = 18446744073709548720LLU;
4909148318 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4909248319 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4909348320 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49096,12 +48323,12 @@
4909648323 state.addr = 587881357514113024LLU; // emitpar___
4909748324 break;
4909848325 }
49099- case 18446744073709548673LLU: // 99999999RA'''''''''''''''
48326+ case 18446744073709548720LLU: // 99999999Ru'''''''''''''''
4910048327 {
49101- state.addr = 18446744073709548674LLU; // 99999999RB'''''''''''''''
48328+ state.addr = 18446744073709548721LLU; // 99999999Rv'''''''''''''''
4910248329 break;
4910348330 }
49104- case 18446744073709548674LLU: // 99999999RB'''''''''''''''
48331+ case 18446744073709548721LLU: // 99999999Rv'''''''''''''''
4910548332 {
4910648333 fprintf(stdout, "%s", " = ");
4910748334 {
@@ -49115,7 +48342,7 @@
4911548342 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4911648343 }
4911748344 // ACCUMULATE ARGUMENTS - END
49118- uint64_t return_to = 18446744073709548671LLU;
48345+ uint64_t return_to = 18446744073709548718LLU;
4911948346 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4912048347 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4912148348 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49124,12 +48351,12 @@
4912448351 state.addr = 787446708198178816LLU; // printnr___
4912548352 break;
4912648353 }
49127- case 18446744073709548671LLU: // 99999999Q9'''''''''''''''
48354+ case 18446744073709548718LLU: // 99999999Rs'''''''''''''''
4912848355 {
49129- state.addr = 18446744073709548672LLU; // 99999999R_'''''''''''''''
48356+ state.addr = 18446744073709548719LLU; // 99999999Rt'''''''''''''''
4913048357 break;
4913148358 }
49132- case 18446744073709548672LLU: // 99999999R_'''''''''''''''
48359+ case 18446744073709548719LLU: // 99999999Rt'''''''''''''''
4913348360 {
4913448361 fprintf(stdout, "%s", ";\n");
4913548362 // variable u64 nr________ goes out of scope
@@ -49137,10 +48364,10 @@
4913748364 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 21
4913848365 heap.availilable_size_for_dynamic_objects += 0LLU;
4913948366 heap.availilable_size_for_dynamic_objects += 0LLU;
49140- state.addr = 18446744073709548670LLU; // 99999999Q8'''''''''''''''
48367+ state.addr = 18446744073709548717LLU; // 99999999Rr'''''''''''''''
4914148368 break;
4914248369 }
49143- case 18446744073709548675LLU: // 99999999RC'''''''''''''''
48370+ case 18446744073709548722LLU: // 99999999Rw'''''''''''''''
4914448371 {
4914548372 {
4914648373 uint64_t arg = 0LLU;
@@ -49147,10 +48374,10 @@
4914748374 LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4914848375 }
4914948376 /*nr________*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 8LLU)));
49150- state.addr = /*nr________*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548669LLU : 18446744073709548668LLU;
48377+ state.addr = /*nr________*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548716LLU : 18446744073709548715LLU;
4915148378 break;
4915248379 }
49153- case 18446744073709548669LLU: // 99999999Q7'''''''''''''''
48380+ case 18446744073709548716LLU: // 99999999Rq'''''''''''''''
4915448381 {
4915548382 // ACCUMULATE ARGUMENTS - BEGIN
4915648383 {
@@ -49162,7 +48389,7 @@
4916248389 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4916348390 }
4916448391 // ACCUMULATE ARGUMENTS - END
49165- uint64_t return_to = 18446744073709548666LLU;
48392+ uint64_t return_to = 18446744073709548713LLU;
4916648393 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4916748394 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4916848395 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49171,22 +48398,22 @@
4917148398 state.addr = 517555565476695680LLU; // assertu64_
4917248399 break;
4917348400 }
49174- case 18446744073709548666LLU: // 99999999Q4'''''''''''''''
48401+ case 18446744073709548713LLU: // 99999999Rn'''''''''''''''
4917548402 {
49176- state.addr = 18446744073709548667LLU; // 99999999Q5'''''''''''''''
48403+ state.addr = 18446744073709548714LLU; // 99999999Ro'''''''''''''''
4917748404 break;
4917848405 }
49179- case 18446744073709548667LLU: // 99999999Q5'''''''''''''''
48406+ case 18446744073709548714LLU: // 99999999Ro'''''''''''''''
4918048407 {
49181- state.addr = 18446744073709548668LLU; // 99999999Q6'''''''''''''''
48408+ state.addr = 18446744073709548715LLU; // 99999999Rp'''''''''''''''
4918248409 break;
4918348410 }
49184- case 18446744073709548668LLU: // 99999999Q6'''''''''''''''
48411+ case 18446744073709548715LLU: // 99999999Rp'''''''''''''''
4918548412 {
49186- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709548665LLU : 18446744073709548664LLU;
48413+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709548712LLU : 18446744073709548711LLU;
4918748414 break;
4918848415 }
49189- case 18446744073709548665LLU: // 99999999Q3'''''''''''''''
48416+ case 18446744073709548712LLU: // 99999999Rm'''''''''''''''
4919048417 {
4919148418 // ACCUMULATE ARGUMENTS - BEGIN
4919248419 {
@@ -49206,7 +48433,7 @@
4920648433 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4920748434 }
4920848435 // ACCUMULATE ARGUMENTS - END
49209- uint64_t return_to = 18446744073709548662LLU;
48436+ uint64_t return_to = 18446744073709548709LLU;
4921048437 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4921148438 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4921248439 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49215,44 +48442,44 @@
4921548442 state.addr = 732615645798520865LLU; // movevarref
4921648443 break;
4921748444 }
49218- case 18446744073709548662LLU: // 99999999Q0'''''''''''''''
48445+ case 18446744073709548709LLU: // 99999999Rj'''''''''''''''
4921948446 {
49220- state.addr = 18446744073709548663LLU; // 99999999Q1'''''''''''''''
48447+ state.addr = 18446744073709548710LLU; // 99999999Rk'''''''''''''''
4922148448 break;
4922248449 }
49223- case 18446744073709548663LLU: // 99999999Q1'''''''''''''''
48450+ case 18446744073709548710LLU: // 99999999Rk'''''''''''''''
4922448451 {
4922548452 heap.availilable_size_for_dynamic_objects += 0LLU;
4922648453 heap.availilable_size_for_dynamic_objects += 0LLU;
49227- state.addr = 18446744073709548661LLU; // 99999999Qz'''''''''''''''
48454+ state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
4922848455 break;
4922948456 }
49230- case 18446744073709548664LLU: // 99999999Q2'''''''''''''''
48457+ case 18446744073709548711LLU: // 99999999Rl'''''''''''''''
4923148458 {
49232- state.addr = 18446744073709548661LLU; // 99999999Qz'''''''''''''''
48459+ state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
4923348460 break;
4923448461 }
49235- case 18446744073709548661LLU: // 99999999Qz'''''''''''''''
48462+ case 18446744073709548708LLU: // 99999999Ri'''''''''''''''
4923648463 {
4923748464 // variable u64 nr________ goes out of scope
4923848465 // emitted destructur for type u64
4923948466 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 21
49240- state.addr = 18446744073709548670LLU; // 99999999Q8'''''''''''''''
48467+ state.addr = 18446744073709548717LLU; // 99999999Rr'''''''''''''''
4924148468 break;
4924248469 }
49243- case 18446744073709548670LLU: // 99999999Q8'''''''''''''''
48470+ case 18446744073709548717LLU: // 99999999Rr'''''''''''''''
4924448471 {
4924548472 heap.availilable_size_for_dynamic_objects += 0LLU;
4924648473 heap.availilable_size_for_dynamic_objects += 0LLU;
49247- state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
48474+ state.addr = 18446744073709548707LLU; // 99999999Rh'''''''''''''''
4924848475 break;
4924948476 }
49250- case 18446744073709548677LLU: // 99999999RE'''''''''''''''
48477+ case 18446744073709548724LLU: // 99999999Ry'''''''''''''''
4925148478 {
49252- state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 20LLU, 13LLU)].elem0 ? 18446744073709548659LLU : 18446744073709548658LLU;
48479+ state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 20LLU, 13LLU)].elem0 ? 18446744073709548706LLU : 18446744073709548705LLU;
4925348480 break;
4925448481 }
49255- case 18446744073709548659LLU: // 99999999Qx'''''''''''''''
48482+ case 18446744073709548706LLU: // 99999999Rg'''''''''''''''
4925648483 {
4925748484 // ACCUMULATE ARGUMENTS - BEGIN
4925848485 {
@@ -49260,7 +48487,7 @@
4926048487 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4926148488 }
4926248489 // ACCUMULATE ARGUMENTS - END
49263- uint64_t return_to = 18446744073709548656LLU;
48490+ uint64_t return_to = 18446744073709548703LLU;
4926448491 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4926548492 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4926648493 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49269,12 +48496,12 @@
4926948496 state.addr = 819847183515949359LLU; // reportinit
4927048497 break;
4927148498 }
49272- case 18446744073709548656LLU: // 99999999Qu'''''''''''''''
48499+ case 18446744073709548703LLU: // 99999999Rd'''''''''''''''
4927348500 {
49274- state.addr = 18446744073709548657LLU; // 99999999Qv'''''''''''''''
48501+ state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
4927548502 break;
4927648503 }
49277- case 18446744073709548657LLU: // 99999999Qv'''''''''''''''
48504+ case 18446744073709548704LLU: // 99999999Re'''''''''''''''
4927848505 {
4927948506 {
4928048507 fprintf(stderr, "%s\n", "assignment to list not implemeted yet");
@@ -49282,10 +48509,10 @@
4928248509 }
4928348510 heap.availilable_size_for_dynamic_objects += 0LLU;
4928448511 heap.availilable_size_for_dynamic_objects += 0LLU;
49285- state.addr = 18446744073709548655LLU; // 99999999Qt'''''''''''''''
48512+ state.addr = 18446744073709548702LLU; // 99999999Rc'''''''''''''''
4928648513 break;
4928748514 }
49288- case 18446744073709548658LLU: // 99999999Qw'''''''''''''''
48515+ case 18446744073709548705LLU: // 99999999Rf'''''''''''''''
4928948516 {
4929048517 {
4929148518 uint64_t arg = 0LLU;
@@ -49297,7 +48524,7 @@
4929748524 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4929848525 }
4929948526 // ACCUMULATE ARGUMENTS - END
49300- uint64_t return_to = 18446744073709548653LLU;
48527+ uint64_t return_to = 18446744073709548700LLU;
4930148528 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4930248529 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4930348530 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49306,12 +48533,12 @@
4930648533 state.addr = 839519719621918720LLU; // skipws____
4930748534 break;
4930848535 }
49309- case 18446744073709548653LLU: // 99999999Qr'''''''''''''''
48536+ case 18446744073709548700LLU: // 99999999Ra'''''''''''''''
4931048537 {
49311- state.addr = 18446744073709548654LLU; // 99999999Qs'''''''''''''''
48538+ state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
4931248539 break;
4931348540 }
49314- case 18446744073709548654LLU: // 99999999Qs'''''''''''''''
48541+ case 18446744073709548701LLU: // 99999999Rb'''''''''''''''
4931548542 {
4931648543 /*srcid_____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 8LLU)));
4931748544 {
@@ -49336,7 +48563,7 @@
4933648563 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4933748564 }
4933848565 // ACCUMULATE ARGUMENTS - END
49339- uint64_t return_to = 18446744073709548651LLU;
48566+ uint64_t return_to = 18446744073709548698LLU;
4934048567 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4934148568 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4934248569 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49345,17 +48572,17 @@
4934548572 state.addr = 728666047794575267LLU; // matchoptch
4934648573 break;
4934748574 }
49348- case 18446744073709548651LLU: // 99999999Qp'''''''''''''''
48575+ case 18446744073709548698LLU: // 99999999RZ'''''''''''''''
4934948576 {
49350- state.addr = 18446744073709548652LLU; // 99999999Qq'''''''''''''''
48577+ state.addr = 18446744073709548699LLU; // 99999999R$'''''''''''''''
4935148578 break;
4935248579 }
49353- case 18446744073709548652LLU: // 99999999Qq'''''''''''''''
48580+ case 18446744073709548699LLU: // 99999999R$'''''''''''''''
4935448581 {
49355- state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548650LLU : 18446744073709548649LLU;
48582+ state.addr = /*called____*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548697LLU : 18446744073709548696LLU;
4935648583 break;
4935748584 }
49358- case 18446744073709548650LLU: // 99999999Qo'''''''''''''''
48585+ case 18446744073709548697LLU: // 99999999RY'''''''''''''''
4935948586 {
4936048587 {
4936148588 uint64_t arg = 0LLU;
@@ -49413,7 +48640,7 @@
4941348640 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4941448641 }
4941548642 // ACCUMULATE ARGUMENTS - END
49416- uint64_t return_to = 18446744073709548647LLU;
48643+ uint64_t return_to = 18446744073709548694LLU;
4941748644 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
4941848645 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4941948646 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49422,12 +48649,12 @@
4942248649 state.addr = 54378275173643538LLU; // CALLCONSTR
4942348650 break;
4942448651 }
49425- case 18446744073709548647LLU: // 99999999Ql'''''''''''''''
48652+ case 18446744073709548694LLU: // 99999999RV'''''''''''''''
4942648653 {
49427- state.addr = 18446744073709548648LLU; // 99999999Qm'''''''''''''''
48654+ state.addr = 18446744073709548695LLU; // 99999999RW'''''''''''''''
4942848655 break;
4942948656 }
49430- case 18446744073709548648LLU: // 99999999Qm'''''''''''''''
48657+ case 18446744073709548695LLU: // 99999999RW'''''''''''''''
4943148658 {
4943248659 fprintf(stdout, "%s", ";\n ");
4943348660 // ACCUMULATE ARGUMENTS - BEGIN
@@ -49452,7 +48679,7 @@
4945248679 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4945348680 }
4945448681 // ACCUMULATE ARGUMENTS - END
49455- uint64_t return_to = 18446744073709548645LLU;
48682+ uint64_t return_to = 18446744073709548692LLU;
4945648683 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4945748684 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4945848685 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49461,12 +48688,12 @@
4946148688 state.addr = 587881357514113024LLU; // emitpar___
4946248689 break;
4946348690 }
49464- case 18446744073709548645LLU: // 99999999Qj'''''''''''''''
48691+ case 18446744073709548692LLU: // 99999999RT'''''''''''''''
4946548692 {
49466- state.addr = 18446744073709548646LLU; // 99999999Qk'''''''''''''''
48693+ state.addr = 18446744073709548693LLU; // 99999999RU'''''''''''''''
4946748694 break;
4946848695 }
49469- case 18446744073709548646LLU: // 99999999Qk'''''''''''''''
48696+ case 18446744073709548693LLU: // 99999999RU'''''''''''''''
4947048697 {
4947148698 fprintf(stdout, "%s", " = arg;");
4947248699 fprintf(stdout, "%s", "\n }");
@@ -49475,10 +48702,10 @@
4947548702 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 24
4947648703 heap.availilable_size_for_dynamic_objects += 0LLU;
4947748704 heap.availilable_size_for_dynamic_objects += 0LLU;
49478- state.addr = 18446744073709548644LLU; // 99999999Qi'''''''''''''''
48705+ state.addr = 18446744073709548691LLU; // 99999999RS'''''''''''''''
4947948706 break;
4948048707 }
49481- case 18446744073709548649LLU: // 99999999Qn'''''''''''''''
48708+ case 18446744073709548696LLU: // 99999999RX'''''''''''''''
4948248709 {
4948348710 // ACCUMULATE ARGUMENTS - BEGIN
4948448711 {
@@ -49490,7 +48717,7 @@
4949048717 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4949148718 }
4949248719 // ACCUMULATE ARGUMENTS - END
49493- uint64_t return_to = 18446744073709548642LLU;
48720+ uint64_t return_to = 18446744073709548689LLU;
4949448721 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4949548722 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4949648723 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49499,12 +48726,12 @@
4949948726 state.addr = 517555565476695680LLU; // assertu64_
4950048727 break;
4950148728 }
49502- case 18446744073709548642LLU: // 99999999Qg'''''''''''''''
48729+ case 18446744073709548689LLU: // 99999999RQ'''''''''''''''
4950348730 {
49504- state.addr = 18446744073709548643LLU; // 99999999Qh'''''''''''''''
48731+ state.addr = 18446744073709548690LLU; // 99999999RR'''''''''''''''
4950548732 break;
4950648733 }
49507- case 18446744073709548643LLU: // 99999999Qh'''''''''''''''
48734+ case 18446744073709548690LLU: // 99999999RR'''''''''''''''
4950848735 {
4950948736 // ACCUMULATE ARGUMENTS - BEGIN
4951048737 {
@@ -49528,7 +48755,7 @@
4952848755 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4952948756 }
4953048757 // ACCUMULATE ARGUMENTS - END
49531- uint64_t return_to = 18446744073709548640LLU;
48758+ uint64_t return_to = 18446744073709548687LLU;
4953248759 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
4953348760 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4953448761 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49537,12 +48764,12 @@
4953748764 state.addr = 587881357514113024LLU; // emitpar___
4953848765 break;
4953948766 }
49540- case 18446744073709548640LLU: // 99999999Qe'''''''''''''''
48767+ case 18446744073709548687LLU: // 99999999RO'''''''''''''''
4954148768 {
49542- state.addr = 18446744073709548641LLU; // 99999999Qf'''''''''''''''
48769+ state.addr = 18446744073709548688LLU; // 99999999RP'''''''''''''''
4954348770 break;
4954448771 }
49545- case 18446744073709548641LLU: // 99999999Qf'''''''''''''''
48772+ case 18446744073709548688LLU: // 99999999RP'''''''''''''''
4954648773 {
4954748774 fprintf(stdout, "%s", " = ");
4954848775 *LOCAL_ACCESS(heap.data, 23LLU, 14LLU) = 0LLU;
@@ -49559,10 +48786,10 @@
4955948786 };
4956048787 *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = arg;
4956148788 }
49562- state.addr = 18446744073709548639LLU; // 99999999Qd'''''''''''''''
48789+ state.addr = 18446744073709548686LLU; // 99999999RN'''''''''''''''
4956348790 break;
4956448791 }
49565- case 18446744073709548639LLU: // 99999999Qd'''''''''''''''
48792+ case 18446744073709548686LLU: // 99999999RN'''''''''''''''
4956648793 {
4956748794 {
4956848795 uint64_t arg = 0LLU;
@@ -49636,7 +48863,7 @@
4963648863 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4963748864 }
4963848865 // ACCUMULATE ARGUMENTS - END
49639- uint64_t return_to = 18446744073709548637LLU;
48866+ uint64_t return_to = 18446744073709548684LLU;
4964048867 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4964148868 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4964248869 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49645,12 +48872,12 @@
4964548872 state.addr = 787472342492567585LLU; // procvarref
4964648873 break;
4964748874 }
49648- case 18446744073709548637LLU: // 99999999Qb'''''''''''''''
48875+ case 18446744073709548684LLU: // 99999999RL'''''''''''''''
4964948876 {
49650- state.addr = 18446744073709548638LLU; // 99999999Qc'''''''''''''''
48877+ state.addr = 18446744073709548685LLU; // 99999999RM'''''''''''''''
4965148878 break;
4965248879 }
49653- case 18446744073709548638LLU: // 99999999Qc'''''''''''''''
48880+ case 18446744073709548685LLU: // 99999999RM'''''''''''''''
4965448881 {
4965548882 // ACCUMULATE ARGUMENTS - BEGIN
4965648883 {
@@ -49670,7 +48897,7 @@
4967048897 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4967148898 }
4967248899 // ACCUMULATE ARGUMENTS - END
49673- uint64_t return_to = 18446744073709548635LLU;
48900+ uint64_t return_to = 18446744073709548682LLU;
4967448901 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
4967548902 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4967648903 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49679,12 +48906,12 @@
4967948906 state.addr = 861504774606571689LLU; // typeassign
4968048907 break;
4968148908 }
49682- case 18446744073709548635LLU: // 99999999Q$'''''''''''''''
48909+ case 18446744073709548682LLU: // 99999999RJ'''''''''''''''
4968348910 {
49684- state.addr = 18446744073709548636LLU; // 99999999Qa'''''''''''''''
48911+ state.addr = 18446744073709548683LLU; // 99999999RK'''''''''''''''
4968548912 break;
4968648913 }
49687- case 18446744073709548636LLU: // 99999999Qa'''''''''''''''
48914+ case 18446744073709548683LLU: // 99999999RK'''''''''''''''
4968848915 {
4968948916 // variable u64 parameter_ goes out of scope
4969048917 // emitted destructur for type u64
@@ -49700,7 +48927,7 @@
4970048927 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4970148928 }
4970248929 // ACCUMULATE ARGUMENTS - END
49703- uint64_t return_to = 18446744073709548634LLU;
48930+ uint64_t return_to = 18446744073709548681LLU;
4970448931 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4970548932 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4970648933 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49709,13 +48936,13 @@
4970948936 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
4971048937 break;
4971148938 }
49712- case 18446744073709548634LLU: // 99999999QZ'''''''''''''''
48939+ case 18446744073709548681LLU: // 99999999RI'''''''''''''''
4971348940 {
4971448941 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 24
49715- state.addr = 18446744073709548644LLU; // 99999999Qi'''''''''''''''
48942+ state.addr = 18446744073709548691LLU; // 99999999RS'''''''''''''''
4971648943 break;
4971748944 }
49718- case 18446744073709548644LLU: // 99999999Qi'''''''''''''''
48945+ case 18446744073709548691LLU: // 99999999RS'''''''''''''''
4971948946 {
4972048947 // variable u64 called____ goes out of scope
4972148948 // emitted destructur for type u64
@@ -49726,21 +48953,21 @@
4972648953 // variable u64 srcid_____ goes out of scope
4972748954 // emitted destructur for type u64
4972848955 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcid_____ at 21
49729- state.addr = 18446744073709548655LLU; // 99999999Qt'''''''''''''''
48956+ state.addr = 18446744073709548702LLU; // 99999999Rc'''''''''''''''
4973048957 break;
4973148958 }
49732- case 18446744073709548655LLU: // 99999999Qt'''''''''''''''
48959+ case 18446744073709548702LLU: // 99999999Rc'''''''''''''''
4973348960 {
4973448961 fprintf(stdout, "%s", ";\n");
49735- state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
48962+ state.addr = 18446744073709548707LLU; // 99999999Rh'''''''''''''''
4973648963 break;
4973748964 }
49738- case 18446744073709548660LLU: // 99999999Qy'''''''''''''''
48965+ case 18446744073709548707LLU: // 99999999Rh'''''''''''''''
4973948966 {
49740- state.addr = 18446744073709548681LLU; // 99999999RI'''''''''''''''
48967+ state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
4974148968 break;
4974248969 }
49743- case 18446744073709548681LLU: // 99999999RI'''''''''''''''
48970+ case 18446744073709548728LLU: // 99999999R2'''''''''''''''
4974448971 {
4974548972 // variable u64 match_____ goes out of scope
4974648973 // emitted destructur for type u64
@@ -49768,7 +48995,7 @@
4976848995 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4976948996 }
4977048997 // ACCUMULATE ARGUMENTS - END
49771- uint64_t return_to = 18446744073709548633LLU;
48998+ uint64_t return_to = 18446744073709548680LLU;
4977248999 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4977349000 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4977449001 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49777,7 +49004,7 @@
4977749004 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
4977849005 break;
4977949006 }
49780- case 18446744073709548633LLU: // 99999999QY'''''''''''''''
49007+ case 18446744073709548680LLU: // 99999999RH'''''''''''''''
4978149008 {
4978249009 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPEDST___ at 14
4978349010 // parameter-reference u64 remainheap goes out of scope
@@ -49826,7 +49053,7 @@
4982649053 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4982749054 }
4982849055 // ACCUMULATE ARGUMENTS - END
49829- uint64_t return_to = 18446744073709548631LLU;
49056+ uint64_t return_to = 18446744073709548678LLU;
4983049057 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4983149058 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4983249059 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49835,12 +49062,12 @@
4983549062 state.addr = 839519719621918720LLU; // skipws____
4983649063 break;
4983749064 }
49838- case 18446744073709548631LLU: // 99999999QW'''''''''''''''
49065+ case 18446744073709548678LLU: // 99999999RF'''''''''''''''
4983949066 {
49840- state.addr = 18446744073709548632LLU; // 99999999QX'''''''''''''''
49067+ state.addr = 18446744073709548679LLU; // 99999999RG'''''''''''''''
4984149068 break;
4984249069 }
49843- case 18446744073709548632LLU: // 99999999QX'''''''''''''''
49070+ case 18446744073709548679LLU: // 99999999RG'''''''''''''''
4984449071 {
4984549072 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)));
4984649073 fprintf(stdout, "%s", "\n list_reverse(heap.data, &");
@@ -49850,7 +49077,7 @@
4985049077 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4985149078 }
4985249079 // ACCUMULATE ARGUMENTS - END
49853- uint64_t return_to = 18446744073709548629LLU;
49080+ uint64_t return_to = 18446744073709548676LLU;
4985449081 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4985549082 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4985649083 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49859,12 +49086,12 @@
4985949086 state.addr = 839519719621918720LLU; // skipws____
4986049087 break;
4986149088 }
49862- case 18446744073709548629LLU: // 99999999QU'''''''''''''''
49089+ case 18446744073709548676LLU: // 99999999RD'''''''''''''''
4986349090 {
49864- state.addr = 18446744073709548630LLU; // 99999999QV'''''''''''''''
49091+ state.addr = 18446744073709548677LLU; // 99999999RE'''''''''''''''
4986549092 break;
4986649093 }
49867- case 18446744073709548630LLU: // 99999999QV'''''''''''''''
49094+ case 18446744073709548677LLU: // 99999999RE'''''''''''''''
4986849095 {
4986949096 {
4987049097 uint64_t arg = 0LLU;
@@ -49882,10 +49109,10 @@
4988249109 };
4988349110 *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = arg;
4988449111 }
49885- state.addr = 18446744073709548628LLU; // 99999999QT'''''''''''''''
49112+ state.addr = 18446744073709548675LLU; // 99999999RC'''''''''''''''
4988649113 break;
4988749114 }
49888- case 18446744073709548628LLU: // 99999999QT'''''''''''''''
49115+ case 18446744073709548675LLU: // 99999999RC'''''''''''''''
4988949116 {
4989049117 {
4989149118 uint64_t arg = 0LLU;
@@ -49897,7 +49124,7 @@
4989749124 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4989849125 }
4989949126 // ACCUMULATE ARGUMENTS - END
49900- uint64_t return_to = 18446744073709548625LLU;
49127+ uint64_t return_to = 18446744073709548672LLU;
4990149128 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4990249129 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4990349130 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49906,12 +49133,12 @@
4990649133 state.addr = 839519719621918720LLU; // skipws____
4990749134 break;
4990849135 }
49909- case 18446744073709548625LLU: // 99999999QQ'''''''''''''''
49136+ case 18446744073709548672LLU: // 99999999R_'''''''''''''''
4991049137 {
49911- state.addr = 18446744073709548626LLU; // 99999999QR'''''''''''''''
49138+ state.addr = 18446744073709548673LLU; // 99999999RA'''''''''''''''
4991249139 break;
4991349140 }
49914- case 18446744073709548626LLU: // 99999999QR'''''''''''''''
49141+ case 18446744073709548673LLU: // 99999999RA'''''''''''''''
4991549142 {
4991649143 /*id________*/*LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
4991749144 {
@@ -49988,7 +49215,7 @@
4998849215 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4998949216 }
4999049217 // ACCUMULATE ARGUMENTS - END
49991- uint64_t return_to = 18446744073709548623LLU;
49218+ uint64_t return_to = 18446744073709548670LLU;
4999249219 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
4999349220 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4999449221 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -49997,12 +49224,12 @@
4999749224 state.addr = 787472342492567585LLU; // procvarref
4999849225 break;
4999949226 }
50000- case 18446744073709548623LLU: // 99999999QO'''''''''''''''
49227+ case 18446744073709548670LLU: // 99999999Q8'''''''''''''''
5000149228 {
50002- state.addr = 18446744073709548624LLU; // 99999999QP'''''''''''''''
49229+ state.addr = 18446744073709548671LLU; // 99999999Q9'''''''''''''''
5000349230 break;
5000449231 }
50005- case 18446744073709548624LLU: // 99999999QP'''''''''''''''
49232+ case 18446744073709548671LLU: // 99999999Q9'''''''''''''''
5000649233 {
5000749234 {
5000849235 uint64_t arg = 0LLU;
@@ -50034,7 +49261,7 @@
5003449261 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5003549262 }
5003649263 // ACCUMULATE ARGUMENTS - END
50037- uint64_t return_to = 18446744073709548621LLU;
49264+ uint64_t return_to = 18446744073709548668LLU;
5003849265 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5003949266 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5004049267 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50043,12 +49270,12 @@
5004349270 state.addr = 734295421765213120LLU; // mutassert_
5004449271 break;
5004549272 }
50046- case 18446744073709548621LLU: // 99999999QM'''''''''''''''
49273+ case 18446744073709548668LLU: // 99999999Q6'''''''''''''''
5004749274 {
50048- state.addr = 18446744073709548622LLU; // 99999999QN'''''''''''''''
49275+ state.addr = 18446744073709548669LLU; // 99999999Q7'''''''''''''''
5004949276 break;
5005049277 }
50051- case 18446744073709548622LLU: // 99999999QN'''''''''''''''
49278+ case 18446744073709548669LLU: // 99999999Q7'''''''''''''''
5005249279 {
5005349280 // variable u64 name______ goes out of scope
5005449281 // emitted destructur for type u64
@@ -50065,10 +49292,10 @@
5006549292 // variable u64 parameter_ goes out of scope
5006649293 // emitted destructur for type u64
5006749294 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 14
50068- state.addr = 18446744073709548627LLU; // 99999999QS'''''''''''''''
49295+ state.addr = 18446744073709548674LLU; // 99999999RB'''''''''''''''
5006949296 break;
5007049297 }
50071- case 18446744073709548627LLU: // 99999999QS'''''''''''''''
49298+ case 18446744073709548674LLU: // 99999999RB'''''''''''''''
5007249299 {
5007349300 // ACCUMULATE ARGUMENTS - BEGIN
5007449301 {
@@ -50080,7 +49307,7 @@
5008049307 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5008149308 }
5008249309 // ACCUMULATE ARGUMENTS - END
50083- uint64_t return_to = 18446744073709548619LLU;
49310+ uint64_t return_to = 18446744073709548666LLU;
5008449311 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5008549312 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5008649313 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50089,12 +49316,12 @@
5008949316 state.addr = 517555565474237359LLU; // assertlist
5009049317 break;
5009149318 }
50092- case 18446744073709548619LLU: // 99999999QK'''''''''''''''
49319+ case 18446744073709548666LLU: // 99999999Q4'''''''''''''''
5009349320 {
50094- state.addr = 18446744073709548620LLU; // 99999999QL'''''''''''''''
49321+ state.addr = 18446744073709548667LLU; // 99999999Q5'''''''''''''''
5009549322 break;
5009649323 }
50097- case 18446744073709548620LLU: // 99999999QL'''''''''''''''
49324+ case 18446744073709548667LLU: // 99999999Q5'''''''''''''''
5009849325 {
5009949326 fprintf(stdout, "%s", ");");
5010049327 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50103,7 +49330,7 @@
5010349330 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5010449331 }
5010549332 // ACCUMULATE ARGUMENTS - END
50106- uint64_t return_to = 18446744073709548617LLU;
49333+ uint64_t return_to = 18446744073709548664LLU;
5010749334 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5010849335 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5010949336 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50112,12 +49339,12 @@
5011249339 state.addr = 839519719621918720LLU; // skipws____
5011349340 break;
5011449341 }
50115- case 18446744073709548617LLU: // 99999999QI'''''''''''''''
49342+ case 18446744073709548664LLU: // 99999999Q2'''''''''''''''
5011649343 {
50117- state.addr = 18446744073709548618LLU; // 99999999QJ'''''''''''''''
49344+ state.addr = 18446744073709548665LLU; // 99999999Q3'''''''''''''''
5011849345 break;
5011949346 }
50120- case 18446744073709548618LLU: // 99999999QJ'''''''''''''''
49347+ case 18446744073709548665LLU: // 99999999Q3'''''''''''''''
5012149348 {
5012249349 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)), stdin);
5012349350 if(')' != (char)getchar())
@@ -50136,7 +49363,7 @@
5013649363 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5013749364 }
5013849365 // ACCUMULATE ARGUMENTS - END
50139- uint64_t return_to = 18446744073709548616LLU;
49366+ uint64_t return_to = 18446744073709548663LLU;
5014049367 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5014149368 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5014249369 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50145,7 +49372,7 @@
5014549372 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5014649373 break;
5014749374 }
50148- case 18446744073709548616LLU: // 99999999QH'''''''''''''''
49375+ case 18446744073709548663LLU: // 99999999Q1'''''''''''''''
5014949376 {
5015049377 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 12
5015149378 // variable u64 id________ goes out of scope
@@ -50192,7 +49419,7 @@
5019249419 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5019349420 }
5019449421 // ACCUMULATE ARGUMENTS - END
50195- uint64_t return_to = 18446744073709548614LLU;
49422+ uint64_t return_to = 18446744073709548661LLU;
5019649423 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5019749424 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5019849425 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50201,12 +49428,12 @@
5020149428 state.addr = 839519719621918720LLU; // skipws____
5020249429 break;
5020349430 }
50204- case 18446744073709548614LLU: // 99999999QF'''''''''''''''
49431+ case 18446744073709548661LLU: // 99999999Qz'''''''''''''''
5020549432 {
50206- state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
49433+ state.addr = 18446744073709548662LLU; // 99999999Q0'''''''''''''''
5020749434 break;
5020849435 }
50209- case 18446744073709548615LLU: // 99999999QG'''''''''''''''
49436+ case 18446744073709548662LLU: // 99999999Q0'''''''''''''''
5021049437 {
5021149438 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)));
5021249439 fprintf(stdout, "%s", "\n list_size(heap.data, ");
@@ -50216,7 +49443,7 @@
5021649443 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5021749444 }
5021849445 // ACCUMULATE ARGUMENTS - END
50219- uint64_t return_to = 18446744073709548612LLU;
49446+ uint64_t return_to = 18446744073709548659LLU;
5022049447 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5022149448 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5022249449 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50225,12 +49452,12 @@
5022549452 state.addr = 839519719621918720LLU; // skipws____
5022649453 break;
5022749454 }
50228- case 18446744073709548612LLU: // 99999999QD'''''''''''''''
49455+ case 18446744073709548659LLU: // 99999999Qx'''''''''''''''
5022949456 {
50230- state.addr = 18446744073709548613LLU; // 99999999QE'''''''''''''''
49457+ state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
5023149458 break;
5023249459 }
50233- case 18446744073709548613LLU: // 99999999QE'''''''''''''''
49460+ case 18446744073709548660LLU: // 99999999Qy'''''''''''''''
5023449461 {
5023549462 {
5023649463 uint64_t arg = 0LLU;
@@ -50248,10 +49475,10 @@
5024849475 };
5024949476 *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = arg;
5025049477 }
50251- state.addr = 18446744073709548611LLU; // 99999999QC'''''''''''''''
49478+ state.addr = 18446744073709548658LLU; // 99999999Qw'''''''''''''''
5025249479 break;
5025349480 }
50254- case 18446744073709548611LLU: // 99999999QC'''''''''''''''
49481+ case 18446744073709548658LLU: // 99999999Qw'''''''''''''''
5025549482 {
5025649483 {
5025749484 uint64_t arg = 0LLU;
@@ -50263,7 +49490,7 @@
5026349490 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5026449491 }
5026549492 // ACCUMULATE ARGUMENTS - END
50266- uint64_t return_to = 18446744073709548608LLU;
49493+ uint64_t return_to = 18446744073709548655LLU;
5026749494 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5026849495 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5026949496 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50272,12 +49499,12 @@
5027249499 state.addr = 839519719621918720LLU; // skipws____
5027349500 break;
5027449501 }
50275- case 18446744073709548608LLU: // 99999999Q_'''''''''''''''
49502+ case 18446744073709548655LLU: // 99999999Qt'''''''''''''''
5027649503 {
50277- state.addr = 18446744073709548609LLU; // 99999999QA'''''''''''''''
49504+ state.addr = 18446744073709548656LLU; // 99999999Qu'''''''''''''''
5027849505 break;
5027949506 }
50280- case 18446744073709548609LLU: // 99999999QA'''''''''''''''
49507+ case 18446744073709548656LLU: // 99999999Qu'''''''''''''''
5028149508 {
5028249509 /*id0_______*/*LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
5028349510 {
@@ -50354,7 +49581,7 @@
5035449581 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5035549582 }
5035649583 // ACCUMULATE ARGUMENTS - END
50357- uint64_t return_to = 18446744073709548606LLU;
49584+ uint64_t return_to = 18446744073709548653LLU;
5035849585 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5035949586 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5036049587 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50363,12 +49590,12 @@
5036349590 state.addr = 787472342492567585LLU; // procvarref
5036449591 break;
5036549592 }
50366- case 18446744073709548606LLU: // 99999999P8'''''''''''''''
49593+ case 18446744073709548653LLU: // 99999999Qr'''''''''''''''
5036749594 {
50368- state.addr = 18446744073709548607LLU; // 99999999P9'''''''''''''''
49595+ state.addr = 18446744073709548654LLU; // 99999999Qs'''''''''''''''
5036949596 break;
5037049597 }
50371- case 18446744073709548607LLU: // 99999999P9'''''''''''''''
49598+ case 18446744073709548654LLU: // 99999999Qs'''''''''''''''
5037249599 {
5037349600 // variable u64 idx_______ goes out of scope
5037449601 // emitted destructur for type u64
@@ -50379,10 +49606,10 @@
5037949606 // variable u64 parameter_ goes out of scope
5038049607 // emitted destructur for type u64
5038149608 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 14
50382- state.addr = 18446744073709548610LLU; // 99999999QB'''''''''''''''
49609+ state.addr = 18446744073709548657LLU; // 99999999Qv'''''''''''''''
5038349610 break;
5038449611 }
50385- case 18446744073709548610LLU: // 99999999QB'''''''''''''''
49612+ case 18446744073709548657LLU: // 99999999Qv'''''''''''''''
5038649613 {
5038749614 // ACCUMULATE ARGUMENTS - BEGIN
5038849615 {
@@ -50394,7 +49621,7 @@
5039449621 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5039549622 }
5039649623 // ACCUMULATE ARGUMENTS - END
50397- uint64_t return_to = 18446744073709548604LLU;
49624+ uint64_t return_to = 18446744073709548651LLU;
5039849625 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5039949626 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5040049627 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50403,12 +49630,12 @@
5040349630 state.addr = 517555565474237359LLU; // assertlist
5040449631 break;
5040549632 }
50406- case 18446744073709548604LLU: // 99999999P6'''''''''''''''
49633+ case 18446744073709548651LLU: // 99999999Qp'''''''''''''''
5040749634 {
50408- state.addr = 18446744073709548605LLU; // 99999999P7'''''''''''''''
49635+ state.addr = 18446744073709548652LLU; // 99999999Qq'''''''''''''''
5040949636 break;
5041049637 }
50411- case 18446744073709548605LLU: // 99999999P7'''''''''''''''
49638+ case 18446744073709548652LLU: // 99999999Qq'''''''''''''''
5041249639 {
5041349640 fprintf(stdout, "%s", ", &");
5041449641 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50417,7 +49644,7 @@
5041749644 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5041849645 }
5041949646 // ACCUMULATE ARGUMENTS - END
50420- uint64_t return_to = 18446744073709548601LLU;
49647+ uint64_t return_to = 18446744073709548648LLU;
5042149648 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5042249649 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5042349650 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50426,18 +49653,18 @@
5042649653 state.addr = 839519719621918720LLU; // skipws____
5042749654 break;
5042849655 }
50429- case 18446744073709548601LLU: // 99999999P3'''''''''''''''
49656+ case 18446744073709548648LLU: // 99999999Qm'''''''''''''''
5043049657 {
50431- state.addr = 18446744073709548602LLU; // 99999999P4'''''''''''''''
49658+ state.addr = 18446744073709548649LLU; // 99999999Qn'''''''''''''''
5043249659 break;
5043349660 }
50434- case 18446744073709548602LLU: // 99999999P4'''''''''''''''
49661+ case 18446744073709548649LLU: // 99999999Qn'''''''''''''''
5043549662 {
5043649663 matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
50437- state.addr = 18446744073709548603LLU; // 99999999P5'''''''''''''''
49664+ state.addr = 18446744073709548650LLU; // 99999999Qo'''''''''''''''
5043849665 break;
5043949666 }
50440- case 18446744073709548603LLU: // 99999999P5'''''''''''''''
49667+ case 18446744073709548650LLU: // 99999999Qo'''''''''''''''
5044149668 {
5044249669 // ACCUMULATE ARGUMENTS - BEGIN
5044349670 {
@@ -50445,7 +49672,7 @@
5044549672 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5044649673 }
5044749674 // ACCUMULATE ARGUMENTS - END
50448- uint64_t return_to = 18446744073709548599LLU;
49675+ uint64_t return_to = 18446744073709548646LLU;
5044949676 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5045049677 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5045149678 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50454,12 +49681,12 @@
5045449681 state.addr = 839519719621918720LLU; // skipws____
5045549682 break;
5045649683 }
50457- case 18446744073709548599LLU: // 99999999P1'''''''''''''''
49684+ case 18446744073709548646LLU: // 99999999Qk'''''''''''''''
5045849685 {
50459- state.addr = 18446744073709548600LLU; // 99999999P2'''''''''''''''
49686+ state.addr = 18446744073709548647LLU; // 99999999Ql'''''''''''''''
5046049687 break;
5046149688 }
50462- case 18446744073709548600LLU: // 99999999P2'''''''''''''''
49689+ case 18446744073709548647LLU: // 99999999Ql'''''''''''''''
5046349690 {
5046449691 {
5046549692 uint64_t arg = 0;
@@ -50473,10 +49700,10 @@
5047349700 };
5047449701 *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = arg;
5047549702 }
50476- state.addr = 18446744073709548598LLU; // 99999999P0'''''''''''''''
49703+ state.addr = 18446744073709548645LLU; // 99999999Qj'''''''''''''''
5047749704 break;
5047849705 }
50479- case 18446744073709548598LLU: // 99999999P0'''''''''''''''
49706+ case 18446744073709548645LLU: // 99999999Qj'''''''''''''''
5048049707 {
5048149708 {
5048249709 uint64_t arg = 0LLU;
@@ -50488,7 +49715,7 @@
5048849715 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5048949716 }
5049049717 // ACCUMULATE ARGUMENTS - END
50491- uint64_t return_to = 18446744073709548595LLU;
49718+ uint64_t return_to = 18446744073709548642LLU;
5049249719 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5049349720 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5049449721 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50497,12 +49724,12 @@
5049749724 state.addr = 839519719621918720LLU; // skipws____
5049849725 break;
5049949726 }
50500- case 18446744073709548595LLU: // 99999999Px'''''''''''''''
49727+ case 18446744073709548642LLU: // 99999999Qg'''''''''''''''
5050149728 {
50502- state.addr = 18446744073709548596LLU; // 99999999Py'''''''''''''''
49729+ state.addr = 18446744073709548643LLU; // 99999999Qh'''''''''''''''
5050349730 break;
5050449731 }
50505- case 18446744073709548596LLU: // 99999999Py'''''''''''''''
49732+ case 18446744073709548643LLU: // 99999999Qh'''''''''''''''
5050649733 {
5050749734 /*id1_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 5LLU)));
5050849735 {
@@ -50587,7 +49814,7 @@
5058749814 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5058849815 }
5058949816 // ACCUMULATE ARGUMENTS - END
50590- uint64_t return_to = 18446744073709548593LLU;
49817+ uint64_t return_to = 18446744073709548640LLU;
5059149818 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5059249819 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5059349820 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50596,12 +49823,12 @@
5059649823 state.addr = 787472342492567585LLU; // procvarref
5059749824 break;
5059849825 }
50599- case 18446744073709548593LLU: // 99999999Pv'''''''''''''''
49826+ case 18446744073709548640LLU: // 99999999Qe'''''''''''''''
5060049827 {
50601- state.addr = 18446744073709548594LLU; // 99999999Pw'''''''''''''''
49828+ state.addr = 18446744073709548641LLU; // 99999999Qf'''''''''''''''
5060249829 break;
5060349830 }
50604- case 18446744073709548594LLU: // 99999999Pw'''''''''''''''
49831+ case 18446744073709548641LLU: // 99999999Qf'''''''''''''''
5060549832 {
5060649833 // ACCUMULATE ARGUMENTS - BEGIN
5060749834 {
@@ -50613,7 +49840,7 @@
5061349840 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5061449841 }
5061549842 // ACCUMULATE ARGUMENTS - END
50616- uint64_t return_to = 18446744073709548591LLU;
49843+ uint64_t return_to = 18446744073709548638LLU;
5061749844 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5061849845 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5061949846 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50622,12 +49849,12 @@
5062249849 state.addr = 517555565476695680LLU; // assertu64_
5062349850 break;
5062449851 }
50625- case 18446744073709548591LLU: // 99999999Pt'''''''''''''''
49852+ case 18446744073709548638LLU: // 99999999Qc'''''''''''''''
5062649853 {
50627- state.addr = 18446744073709548592LLU; // 99999999Pu'''''''''''''''
49854+ state.addr = 18446744073709548639LLU; // 99999999Qd'''''''''''''''
5062849855 break;
5062949856 }
50630- case 18446744073709548592LLU: // 99999999Pu'''''''''''''''
49857+ case 18446744073709548639LLU: // 99999999Qd'''''''''''''''
5063149858 {
5063249859 {
5063349860 uint64_t arg = 2LLU;
@@ -50655,7 +49882,7 @@
5065549882 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5065649883 }
5065749884 // ACCUMULATE ARGUMENTS - END
50658- uint64_t return_to = 18446744073709548589LLU;
49885+ uint64_t return_to = 18446744073709548636LLU;
5065949886 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5066049887 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5066149888 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50664,12 +49891,12 @@
5066449891 state.addr = 734295421765213120LLU; // mutassert_
5066549892 break;
5066649893 }
50667- case 18446744073709548589LLU: // 99999999Pr'''''''''''''''
49894+ case 18446744073709548636LLU: // 99999999Qa'''''''''''''''
5066849895 {
50669- state.addr = 18446744073709548590LLU; // 99999999Ps'''''''''''''''
49896+ state.addr = 18446744073709548637LLU; // 99999999Qb'''''''''''''''
5067049897 break;
5067149898 }
50672- case 18446744073709548590LLU: // 99999999Ps'''''''''''''''
49899+ case 18446744073709548637LLU: // 99999999Qb'''''''''''''''
5067349900 {
5067449901 // variable u64 parnr_____ goes out of scope
5067549902 // emitted destructur for type u64
@@ -50692,10 +49919,10 @@
5069249919 // variable u64 id1_______ goes out of scope
5069349920 // emitted destructur for type u64
5069449921 (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 15
50695- state.addr = 18446744073709548597LLU; // 99999999Pz'''''''''''''''
49922+ state.addr = 18446744073709548644LLU; // 99999999Qi'''''''''''''''
5069649923 break;
5069749924 }
50698- case 18446744073709548597LLU: // 99999999Pz'''''''''''''''
49925+ case 18446744073709548644LLU: // 99999999Qi'''''''''''''''
5069949926 {
5070049927 fprintf(stdout, "%s", ");");
5070149928 // ACCUMULATE ARGUMENTS - BEGIN
@@ -50704,7 +49931,7 @@
5070449931 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5070549932 }
5070649933 // ACCUMULATE ARGUMENTS - END
50707- uint64_t return_to = 18446744073709548587LLU;
49934+ uint64_t return_to = 18446744073709548634LLU;
5070849935 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5070949936 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5071049937 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50713,12 +49940,12 @@
5071349940 state.addr = 839519719621918720LLU; // skipws____
5071449941 break;
5071549942 }
50716- case 18446744073709548587LLU: // 99999999Pp'''''''''''''''
49943+ case 18446744073709548634LLU: // 99999999QZ'''''''''''''''
5071749944 {
50718- state.addr = 18446744073709548588LLU; // 99999999Pq'''''''''''''''
49945+ state.addr = 18446744073709548635LLU; // 99999999Q$'''''''''''''''
5071949946 break;
5072049947 }
50721- case 18446744073709548588LLU: // 99999999Pq'''''''''''''''
49948+ case 18446744073709548635LLU: // 99999999Q$'''''''''''''''
5072249949 {
5072349950 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)), stdin);
5072449951 if(')' != (char)getchar())
@@ -50734,7 +49961,7 @@
5073449961 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5073549962 }
5073649963 // ACCUMULATE ARGUMENTS - END
50737- uint64_t return_to = 18446744073709548586LLU;
49964+ uint64_t return_to = 18446744073709548633LLU;
5073849965 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5073949966 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5074049967 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50743,7 +49970,7 @@
5074349970 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5074449971 break;
5074549972 }
50746- case 18446744073709548586LLU: // 99999999Po'''''''''''''''
49973+ case 18446744073709548633LLU: // 99999999QY'''''''''''''''
5074749974 {
5074849975 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 14
5074949976 // variable u64 mutable0__ goes out of scope
@@ -50757,7 +49984,7 @@
5075749984 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5075849985 }
5075949986 // ACCUMULATE ARGUMENTS - END
50760- uint64_t return_to = 18446744073709548585LLU;
49987+ uint64_t return_to = 18446744073709548632LLU;
5076149988 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5076249989 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5076349990 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50766,7 +49993,7 @@
5076649993 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5076749994 break;
5076849995 }
50769- case 18446744073709548585LLU: // 99999999Pn'''''''''''''''
49996+ case 18446744073709548632LLU: // 99999999QX'''''''''''''''
5077049997 {
5077149998 (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 12
5077249999 // variable u64 id0_______ goes out of scope
@@ -50817,7 +50044,7 @@
5081750044 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5081850045 }
5081950046 // ACCUMULATE ARGUMENTS - END
50820- uint64_t return_to = 18446744073709548583LLU;
50047+ uint64_t return_to = 18446744073709548630LLU;
5082150048 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5082250049 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5082350050 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50826,12 +50053,12 @@
5082650053 state.addr = 517555828430075934LLU; // assign_dec
5082750054 break;
5082850055 }
50829- case 18446744073709548583LLU: // 99999999Pl'''''''''''''''
50056+ case 18446744073709548630LLU: // 99999999QV'''''''''''''''
5083050057 {
50831- state.addr = 18446744073709548584LLU; // 99999999Pm'''''''''''''''
50058+ state.addr = 18446744073709548631LLU; // 99999999QW'''''''''''''''
5083250059 break;
5083350060 }
50834- case 18446744073709548584LLU: // 99999999Pm'''''''''''''''
50061+ case 18446744073709548631LLU: // 99999999QW'''''''''''''''
5083550062 {
5083650063 {
5083750064 uint64_t arg = 0LLU;
@@ -50847,7 +50074,7 @@
5084750074 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5084850075 }
5084950076 // ACCUMULATE ARGUMENTS - END
50850- uint64_t return_to = 18446744073709548581LLU;
50077+ uint64_t return_to = 18446744073709548628LLU;
5085150078 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5085250079 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5085350080 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50856,12 +50083,12 @@
5085650083 state.addr = 517555828430075934LLU; // assign_dec
5085750084 break;
5085850085 }
50859- case 18446744073709548581LLU: // 99999999Pj'''''''''''''''
50086+ case 18446744073709548628LLU: // 99999999QT'''''''''''''''
5086050087 {
50861- state.addr = 18446744073709548582LLU; // 99999999Pk'''''''''''''''
50088+ state.addr = 18446744073709548629LLU; // 99999999QU'''''''''''''''
5086250089 break;
5086350090 }
50864- case 18446744073709548582LLU: // 99999999Pk'''''''''''''''
50091+ case 18446744073709548629LLU: // 99999999QU'''''''''''''''
5086550092 {
5086650093 {
5086750094 uint64_t arg = 0LLU;
@@ -50887,10 +50114,10 @@
5088750114 };
5088850115 *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = arg;
5088950116 }
50890- state.addr = 18446744073709548580LLU; // 99999999Pi'''''''''''''''
50117+ state.addr = 18446744073709548627LLU; // 99999999QS'''''''''''''''
5089150118 break;
5089250119 }
50893- case 18446744073709548580LLU: // 99999999Pi'''''''''''''''
50120+ case 18446744073709548627LLU: // 99999999QS'''''''''''''''
5089450121 {
5089550122 fprintf(stdout, "%s", "\n state.addr = !list_push_move(&heap, ");
5089650123 fprintf(stdout, "%s", "&");
@@ -50900,7 +50127,7 @@
5090050127 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5090150128 }
5090250129 // ACCUMULATE ARGUMENTS - END
50903- uint64_t return_to = 18446744073709548576LLU;
50130+ uint64_t return_to = 18446744073709548623LLU;
5090450131 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5090550132 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5090650133 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50909,12 +50136,12 @@
5090950136 state.addr = 839519719621918720LLU; // skipws____
5091050137 break;
5091150138 }
50912- case 18446744073709548576LLU: // 99999999Pe'''''''''''''''
50139+ case 18446744073709548623LLU: // 99999999QO'''''''''''''''
5091350140 {
50914- state.addr = 18446744073709548577LLU; // 99999999Pf'''''''''''''''
50141+ state.addr = 18446744073709548624LLU; // 99999999QP'''''''''''''''
5091550142 break;
5091650143 }
50917- case 18446744073709548577LLU: // 99999999Pf'''''''''''''''
50144+ case 18446744073709548624LLU: // 99999999QP'''''''''''''''
5091850145 {
5091950146 /*elemid____*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 8LLU)));
5092050147 {
@@ -50990,7 +50217,7 @@
5099050217 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5099150218 }
5099250219 // ACCUMULATE ARGUMENTS - END
50993- uint64_t return_to = 18446744073709548573LLU;
50220+ uint64_t return_to = 18446744073709548620LLU;
5099450221 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
5099550222 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5099650223 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -50999,12 +50226,12 @@
5099950226 state.addr = 604790753280317473LLU; // findvarref
5100050227 break;
5100150228 }
51002- case 18446744073709548573LLU: // 99999999Pb'''''''''''''''
50229+ case 18446744073709548620LLU: // 99999999QL'''''''''''''''
5100350230 {
51004- state.addr = 18446744073709548574LLU; // 99999999Pc'''''''''''''''
50231+ state.addr = 18446744073709548621LLU; // 99999999QM'''''''''''''''
5100550232 break;
5100650233 }
51007- case 18446744073709548574LLU: // 99999999Pc'''''''''''''''
50234+ case 18446744073709548621LLU: // 99999999QM'''''''''''''''
5100850235 {
5100950236 // variable u64 consume___ goes out of scope
5101050237 // emitted destructur for type u64
@@ -51012,15 +50239,15 @@
5101250239 // variable u64 optelem___ goes out of scope
5101350240 // emitted destructur for type u64
5101450241 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 23
51015- state.addr = 18446744073709548575LLU; // 99999999Pd'''''''''''''''
50242+ state.addr = 18446744073709548622LLU; // 99999999QN'''''''''''''''
5101650243 break;
5101750244 }
51018- case 18446744073709548575LLU: // 99999999Pd'''''''''''''''
50245+ case 18446744073709548622LLU: // 99999999QN'''''''''''''''
5101950246 {
51020- state.addr = /*parameter_*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709548572LLU : 18446744073709548571LLU;
50247+ state.addr = /*parameter_*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709548619LLU : 18446744073709548618LLU;
5102150248 break;
5102250249 }
51023- case 18446744073709548572LLU: // 99999999Pa'''''''''''''''
50250+ case 18446744073709548619LLU: // 99999999QK'''''''''''''''
5102450251 {
5102550252 fprintf(stderr, "%s", "in function ");
5102650253 printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
@@ -51031,22 +50258,22 @@
5103150258 fprintf(stderr, "%s\n", "");
5103250259 exit(-1);
5103350260 }
51034- state.addr = 18446744073709548571LLU; // 99999999P$'''''''''''''''
50261+ state.addr = 18446744073709548618LLU; // 99999999QJ'''''''''''''''
5103550262 break;
5103650263 }
51037- case 18446744073709548571LLU: // 99999999P$'''''''''''''''
50264+ case 18446744073709548618LLU: // 99999999QJ'''''''''''''''
5103850265 {
51039- state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548570LLU : 18446744073709548569LLU;
50266+ state.addr = /*initialize*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548617LLU : 18446744073709548616LLU;
5104050267 break;
5104150268 }
51042- case 18446744073709548570LLU: // 99999999PZ'''''''''''''''
50269+ case 18446744073709548617LLU: // 99999999QI'''''''''''''''
5104350270 {
5104450271 heap.availilable_size_for_dynamic_objects += 0LLU;
5104550272 heap.availilable_size_for_dynamic_objects += 0LLU;
51046- state.addr = 18446744073709548568LLU; // 99999999PX'''''''''''''''
50273+ state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
5104750274 break;
5104850275 }
51049- case 18446744073709548569LLU: // 99999999PY'''''''''''''''
50276+ case 18446744073709548616LLU: // 99999999QH'''''''''''''''
5105050277 {
5105150278 // ACCUMULATE ARGUMENTS - BEGIN
5105250279 {
@@ -51054,7 +50281,7 @@
5105450281 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5105550282 }
5105650283 // ACCUMULATE ARGUMENTS - END
51057- uint64_t return_to = 18446744073709548566LLU;
50284+ uint64_t return_to = 18446744073709548613LLU;
5105850285 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5105950286 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5106050287 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51063,12 +50290,12 @@
5106350290 state.addr = 819847183515949359LLU; // reportinit
5106450291 break;
5106550292 }
51066- case 18446744073709548566LLU: // 99999999PV'''''''''''''''
50293+ case 18446744073709548613LLU: // 99999999QE'''''''''''''''
5106750294 {
51068- state.addr = 18446744073709548567LLU; // 99999999PW'''''''''''''''
50295+ state.addr = 18446744073709548614LLU; // 99999999QF'''''''''''''''
5106950296 break;
5107050297 }
51071- case 18446744073709548567LLU: // 99999999PW'''''''''''''''
50298+ case 18446744073709548614LLU: // 99999999QF'''''''''''''''
5107250299 {
5107350300 fprintf(stderr, "%s", "[ifpushfail] unitialized variable ");
5107450301 printid(stderr, /*elemid____*/*LOCAL_ACCESS(heap.data, 22LLU, 17LLU));
@@ -51076,10 +50303,10 @@
5107650303 fprintf(stderr, "%s\n", "");
5107750304 exit(-1);
5107850305 }
51079- state.addr = 18446744073709548568LLU; // 99999999PX'''''''''''''''
50306+ state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
5108050307 break;
5108150308 }
51082- case 18446744073709548568LLU: // 99999999PX'''''''''''''''
50309+ case 18446744073709548615LLU: // 99999999QG'''''''''''''''
5108350310 {
5108450311 // ACCUMULATE ARGUMENTS - BEGIN
5108550312 {
@@ -51103,7 +50330,7 @@
5110350330 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5110450331 }
5110550332 // ACCUMULATE ARGUMENTS - END
51106- uint64_t return_to = 18446744073709548564LLU;
50333+ uint64_t return_to = 18446744073709548611LLU;
5110750334 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5110850335 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5110950336 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51112,12 +50339,12 @@
5111250339 state.addr = 587881357514113024LLU; // emitpar___
5111350340 break;
5111450341 }
51115- case 18446744073709548564LLU: // 99999999PT'''''''''''''''
50342+ case 18446744073709548611LLU: // 99999999QC'''''''''''''''
5111650343 {
51117- state.addr = 18446744073709548565LLU; // 99999999PU'''''''''''''''
50344+ state.addr = 18446744073709548612LLU; // 99999999QD'''''''''''''''
5111850345 break;
5111950346 }
51120- case 18446744073709548565LLU: // 99999999PU'''''''''''''''
50347+ case 18446744073709548612LLU: // 99999999QD'''''''''''''''
5112150348 {
5112250349 // variable u64 initialize goes out of scope
5112350350 // emitted destructur for type u64
@@ -51128,10 +50355,10 @@
5112850355 // variable u64 mutable___ goes out of scope
5112950356 // emitted destructur for type u64
5113050357 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 20
51131- state.addr = 18446744073709548578LLU; // 99999999Pg'''''''''''''''
50358+ state.addr = 18446744073709548625LLU; // 99999999QQ'''''''''''''''
5113250359 break;
5113350360 }
51134- case 18446744073709548578LLU: // 99999999Pg'''''''''''''''
50361+ case 18446744073709548625LLU: // 99999999QQ'''''''''''''''
5113550362 {
5113650363 fprintf(stdout, "%s", ", ");
5113750364 {
@@ -51150,10 +50377,10 @@
5115050377 };
5115150378 *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = arg;
5115250379 }
51153- state.addr = 18446744073709548563LLU; // 99999999PS'''''''''''''''
50380+ state.addr = 18446744073709548610LLU; // 99999999QB'''''''''''''''
5115450381 break;
5115550382 }
51156- case 18446744073709548563LLU: // 99999999PS'''''''''''''''
50383+ case 18446744073709548610LLU: // 99999999QB'''''''''''''''
5115750384 {
5115850385 fprintf(stdout, "%s", "&");
5115950386 {
@@ -51166,7 +50393,7 @@
5116650393 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5116750394 }
5116850395 // ACCUMULATE ARGUMENTS - END
51169- uint64_t return_to = 18446744073709548560LLU;
50396+ uint64_t return_to = 18446744073709548607LLU;
5117050397 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5117150398 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5117250399 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51175,12 +50402,12 @@
5117550402 state.addr = 839519719621918720LLU; // skipws____
5117650403 break;
5117750404 }
51178- case 18446744073709548560LLU: // 99999999PP'''''''''''''''
50405+ case 18446744073709548607LLU: // 99999999P9'''''''''''''''
5117950406 {
51180- state.addr = 18446744073709548561LLU; // 99999999PQ'''''''''''''''
50407+ state.addr = 18446744073709548608LLU; // 99999999Q_'''''''''''''''
5118150408 break;
5118250409 }
51183- case 18446744073709548561LLU: // 99999999PQ'''''''''''''''
50410+ case 18446744073709548608LLU: // 99999999Q_'''''''''''''''
5118450411 {
5118550412 /*id________*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 8LLU)));
5118650413 {
@@ -51261,7 +50488,7 @@
5126150488 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5126250489 }
5126350490 // ACCUMULATE ARGUMENTS - END
51264- uint64_t return_to = 18446744073709548558LLU;
50491+ uint64_t return_to = 18446744073709548605LLU;
5126550492 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
5126650493 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5126750494 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51270,17 +50497,17 @@
5127050497 state.addr = 787472342492567585LLU; // procvarref
5127150498 break;
5127250499 }
51273- case 18446744073709548558LLU: // 99999999PN'''''''''''''''
50500+ case 18446744073709548605LLU: // 99999999P7'''''''''''''''
5127450501 {
51275- state.addr = 18446744073709548559LLU; // 99999999PO'''''''''''''''
50502+ state.addr = 18446744073709548606LLU; // 99999999P8'''''''''''''''
5127650503 break;
5127750504 }
51278- case 18446744073709548559LLU: // 99999999PO'''''''''''''''
50505+ case 18446744073709548606LLU: // 99999999P8'''''''''''''''
5127950506 {
51280- state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 26LLU, 20LLU)].elem0 ? 18446744073709548557LLU : 18446744073709548556LLU;
50507+ state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 26LLU, 20LLU)].elem0 ? 18446744073709548604LLU : 18446744073709548603LLU;
5128150508 break;
5128250509 }
51283- case 18446744073709548557LLU: // 99999999PM'''''''''''''''
50510+ case 18446744073709548604LLU: // 99999999P6'''''''''''''''
5128450511 {
5128550512 {
5128650513 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, LOCAL_ACCESS_ADDR(heap.data, 26LLU, 20LLU), 1/*content*/), 0LLU);
@@ -51308,7 +50535,7 @@
5130850535 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5130950536 }
5131050537 // ACCUMULATE ARGUMENTS - END
51311- uint64_t return_to = 18446744073709548554LLU;
50538+ uint64_t return_to = 18446744073709548601LLU;
5131250539 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5131350540 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5131450541 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51317,12 +50544,12 @@
5131750544 state.addr = 367395566849966080LLU; // TYPEINIT__
5131850545 break;
5131950546 }
51320- case 18446744073709548554LLU: // 99999999PJ'''''''''''''''
50547+ case 18446744073709548601LLU: // 99999999P3'''''''''''''''
5132150548 {
51322- state.addr = 18446744073709548555LLU; // 99999999PK'''''''''''''''
50549+ state.addr = 18446744073709548602LLU; // 99999999P4'''''''''''''''
5132350550 break;
5132450551 }
51325- case 18446744073709548555LLU: // 99999999PK'''''''''''''''
50552+ case 18446744073709548602LLU: // 99999999P4'''''''''''''''
5132650553 {
5132750554 // ACCUMULATE ARGUMENTS - BEGIN
5132850555 {
@@ -51342,7 +50569,7 @@
5134250569 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5134350570 }
5134450571 // ACCUMULATE ARGUMENTS - END
51345- uint64_t return_to = 18446744073709548552LLU;
50572+ uint64_t return_to = 18446744073709548599LLU;
5134650573 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5134750574 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5134850575 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51351,12 +50578,12 @@
5135150578 state.addr = 861504774606571689LLU; // typeassign
5135250579 break;
5135350580 }
51354- case 18446744073709548552LLU: // 99999999PH'''''''''''''''
50581+ case 18446744073709548599LLU: // 99999999P1'''''''''''''''
5135550582 {
51356- state.addr = 18446744073709548553LLU; // 99999999PI'''''''''''''''
50583+ state.addr = 18446744073709548600LLU; // 99999999P2'''''''''''''''
5135750584 break;
5135850585 }
51359- case 18446744073709548553LLU: // 99999999PI'''''''''''''''
50586+ case 18446744073709548600LLU: // 99999999P2'''''''''''''''
5136050587 {
5136150588 // variable type______ tmp_______ goes out of scope
5136250589 // emitted destructur for type type______
@@ -51366,7 +50593,7 @@
5136650593 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5136750594 }
5136850595 // ACCUMULATE ARGUMENTS - END
51369- uint64_t return_to = 18446744073709548551LLU;
50596+ uint64_t return_to = 18446744073709548598LLU;
5137050597 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5137150598 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5137250599 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51375,7 +50602,7 @@
5137550602 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5137650603 break;
5137750604 }
51378- case 18446744073709548551LLU: // 99999999PG'''''''''''''''
50605+ case 18446744073709548598LLU: // 99999999P0'''''''''''''''
5137950606 {
5138050607 (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 29
5138150608 // variable u64 zero______ goes out of scope
@@ -51385,10 +50612,10 @@
5138550612 (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 27
5138650613 heap.availilable_size_for_dynamic_objects += 0LLU;
5138750614 heap.availilable_size_for_dynamic_objects += 0LLU;
51388- state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
50615+ state.addr = 18446744073709548597LLU; // 99999999Pz'''''''''''''''
5138950616 break;
5139050617 }
51391- case 18446744073709548556LLU: // 99999999PL'''''''''''''''
50618+ case 18446744073709548603LLU: // 99999999P5'''''''''''''''
5139250619 {
5139350620 printid(stderr, /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 26LLU, 7LLU)));
5139450621 fprintf(stderr, "%s", ": need list but found ");
@@ -51398,7 +50625,7 @@
5139850625 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5139950626 }
5140050627 // ACCUMULATE ARGUMENTS - END
51401- uint64_t return_to = 18446744073709548548LLU;
50628+ uint64_t return_to = 18446744073709548595LLU;
5140250629 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5140350630 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5140450631 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51407,21 +50634,21 @@
5140750634 state.addr = 819847183518878432LLU; // reporttype
5140850635 break;
5140950636 }
51410- case 18446744073709548548LLU: // 99999999PD'''''''''''''''
50637+ case 18446744073709548595LLU: // 99999999Px'''''''''''''''
5141150638 {
51412- state.addr = 18446744073709548549LLU; // 99999999PE'''''''''''''''
50639+ state.addr = 18446744073709548596LLU; // 99999999Py'''''''''''''''
5141350640 break;
5141450641 }
51415- case 18446744073709548549LLU: // 99999999PE'''''''''''''''
50642+ case 18446744073709548596LLU: // 99999999Py'''''''''''''''
5141650643 {
5141750644 {
5141850645 fprintf(stderr, "%s\n", "");
5141950646 exit(-1);
5142050647 }
51421- state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
50648+ state.addr = 18446744073709548597LLU; // 99999999Pz'''''''''''''''
5142250649 break;
5142350650 }
51424- case 18446744073709548550LLU: // 99999999PF'''''''''''''''
50651+ case 18446744073709548597LLU: // 99999999Pz'''''''''''''''
5142550652 {
5142650653 {
5142750654 uint64_t arg = 2LLU;
@@ -51449,7 +50676,7 @@
5144950676 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5145050677 }
5145150678 // ACCUMULATE ARGUMENTS - END
51452- uint64_t return_to = 18446744073709548546LLU;
50679+ uint64_t return_to = 18446744073709548593LLU;
5145350680 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5145450681 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5145550682 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51458,12 +50685,12 @@
5145850685 state.addr = 734295421765213120LLU; // mutassert_
5145950686 break;
5146050687 }
51461- case 18446744073709548546LLU: // 99999999PB'''''''''''''''
50688+ case 18446744073709548593LLU: // 99999999Pv'''''''''''''''
5146250689 {
51463- state.addr = 18446744073709548547LLU; // 99999999PC'''''''''''''''
50690+ state.addr = 18446744073709548594LLU; // 99999999Pw'''''''''''''''
5146450691 break;
5146550692 }
51466- case 18446744073709548547LLU: // 99999999PC'''''''''''''''
50693+ case 18446744073709548594LLU: // 99999999Pw'''''''''''''''
5146750694 {
5146850695 // variable u64 parnr_____ goes out of scope
5146950696 // emitted destructur for type u64
@@ -51483,10 +50710,10 @@
5148350710 // variable u64 id________ goes out of scope
5148450711 // emitted destructur for type u64
5148550712 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 22
51486- state.addr = 18446744073709548562LLU; // 99999999PR'''''''''''''''
50713+ state.addr = 18446744073709548609LLU; // 99999999QA'''''''''''''''
5148750714 break;
5148850715 }
51489- case 18446744073709548562LLU: // 99999999PR'''''''''''''''
50716+ case 18446744073709548609LLU: // 99999999QA'''''''''''''''
5149050717 {
5149150718 {
5149250719 uint64_t arg = 0LLU;
@@ -51510,7 +50737,7 @@
5151050737 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5151150738 }
5151250739 // ACCUMULATE ARGUMENTS - END
51513- uint64_t return_to = 18446744073709548543LLU;
50740+ uint64_t return_to = 18446744073709548590LLU;
5151450741 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5151550742 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5151650743 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51519,12 +50746,12 @@
5151950746 state.addr = 375116000798050091LLU; // TypeOnHeap
5152050747 break;
5152150748 }
51522- case 18446744073709548543LLU: // 99999999O9'''''''''''''''
50749+ case 18446744073709548590LLU: // 99999999Ps'''''''''''''''
5152350750 {
51524- state.addr = 18446744073709548544LLU; // 99999999P_'''''''''''''''
50751+ state.addr = 18446744073709548591LLU; // 99999999Pt'''''''''''''''
5152550752 break;
5152650753 }
51527- case 18446744073709548544LLU: // 99999999P_'''''''''''''''
50754+ case 18446744073709548591LLU: // 99999999Pt'''''''''''''''
5152850755 {
5152950756 ++/*reqsize___*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU);
5153050757 fprintf(stdout, "%s", ", ");
@@ -51532,10 +50759,10 @@
5153250759 // variable u64 reqsize___ goes out of scope
5153350760 // emitted destructur for type u64
5153450761 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reqsize___ at 22
51535- state.addr = 18446744073709548545LLU; // 99999999PA'''''''''''''''
50762+ state.addr = 18446744073709548592LLU; // 99999999Pu'''''''''''''''
5153650763 break;
5153750764 }
51538- case 18446744073709548545LLU: // 99999999PA'''''''''''''''
50765+ case 18446744073709548592LLU: // 99999999Pu'''''''''''''''
5153950766 {
5154050767 fprintf(stdout, "%s", ") ? ");
5154150768 // ACCUMULATE ARGUMENTS - BEGIN
@@ -51544,7 +50771,7 @@
5154450771 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5154550772 }
5154650773 // ACCUMULATE ARGUMENTS - END
51547- uint64_t return_to = 18446744073709548541LLU;
50774+ uint64_t return_to = 18446744073709548588LLU;
5154850775 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5154950776 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5155050777 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51553,12 +50780,12 @@
5155350780 state.addr = 787446708198178816LLU; // printnr___
5155450781 break;
5155550782 }
51556- case 18446744073709548541LLU: // 99999999O7'''''''''''''''
50783+ case 18446744073709548588LLU: // 99999999Pq'''''''''''''''
5155750784 {
51558- state.addr = 18446744073709548542LLU; // 99999999O8'''''''''''''''
50785+ state.addr = 18446744073709548589LLU; // 99999999Pr'''''''''''''''
5155950786 break;
5156050787 }
51561- case 18446744073709548542LLU: // 99999999O8'''''''''''''''
50788+ case 18446744073709548589LLU: // 99999999Pr'''''''''''''''
5156250789 {
5156350790 fprintf(stdout, "%s", " : ");
5156450791 // ACCUMULATE ARGUMENTS - BEGIN
@@ -51567,7 +50794,7 @@
5156750794 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5156850795 }
5156950796 // ACCUMULATE ARGUMENTS - END
51570- uint64_t return_to = 18446744073709548539LLU;
50797+ uint64_t return_to = 18446744073709548586LLU;
5157150798 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5157250799 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5157350800 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51576,12 +50803,12 @@
5157650803 state.addr = 787446708198178816LLU; // printnr___
5157750804 break;
5157850805 }
51579- case 18446744073709548539LLU: // 99999999O5'''''''''''''''
50806+ case 18446744073709548586LLU: // 99999999Po'''''''''''''''
5158050807 {
51581- state.addr = 18446744073709548540LLU; // 99999999O6'''''''''''''''
50808+ state.addr = 18446744073709548587LLU; // 99999999Pp'''''''''''''''
5158250809 break;
5158350810 }
51584- case 18446744073709548540LLU: // 99999999O6'''''''''''''''
50811+ case 18446744073709548587LLU: // 99999999Pp'''''''''''''''
5158550812 {
5158650813 fprintf(stdout, "%s", ";");
5158750814 {
@@ -51594,7 +50821,7 @@
5159450821 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5159550822 }
5159650823 // ACCUMULATE ARGUMENTS - END
51597- uint64_t return_to = 18446744073709548536LLU;
50824+ uint64_t return_to = 18446744073709548583LLU;
5159850825 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5159950826 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5160050827 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51603,20 +50830,20 @@
5160350830 state.addr = 587881351406074923LLU; // emitjumpup
5160450831 break;
5160550832 }
51606- case 18446744073709548536LLU: // 99999999O2'''''''''''''''
50833+ case 18446744073709548583LLU: // 99999999Pl'''''''''''''''
5160750834 {
51608- state.addr = 18446744073709548537LLU; // 99999999O3'''''''''''''''
50835+ state.addr = 18446744073709548584LLU; // 99999999Pm'''''''''''''''
5160950836 break;
5161050837 }
51611- case 18446744073709548537LLU: // 99999999O3'''''''''''''''
50838+ case 18446744073709548584LLU: // 99999999Pm'''''''''''''''
5161250839 {
5161350840 // variable u64 level_____ goes out of scope
5161450841 // emitted destructur for type u64
5161550842 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 22
51616- state.addr = 18446744073709548538LLU; // 99999999O4'''''''''''''''
50843+ state.addr = 18446744073709548585LLU; // 99999999Pn'''''''''''''''
5161750844 break;
5161850845 }
51619- case 18446744073709548538LLU: // 99999999O4'''''''''''''''
50846+ case 18446744073709548585LLU: // 99999999Pn'''''''''''''''
5162050847 {
5162150848 // ACCUMULATE ARGUMENTS - BEGIN
5162250849 {
@@ -51624,7 +50851,7 @@
5162450851 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5162550852 }
5162650853 // ACCUMULATE ARGUMENTS - END
51627- uint64_t return_to = 18446744073709548534LLU;
50854+ uint64_t return_to = 18446744073709548581LLU;
5162850855 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5162950856 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5163050857 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51633,12 +50860,12 @@
5163350860 state.addr = 587881345921715008LLU; // emitenter_
5163450861 break;
5163550862 }
51636- case 18446744073709548534LLU: // 99999999O0'''''''''''''''
50863+ case 18446744073709548581LLU: // 99999999Pj'''''''''''''''
5163750864 {
51638- state.addr = 18446744073709548535LLU; // 99999999O1'''''''''''''''
50865+ state.addr = 18446744073709548582LLU; // 99999999Pk'''''''''''''''
5163950866 break;
5164050867 }
51641- case 18446744073709548535LLU: // 99999999O1'''''''''''''''
50868+ case 18446744073709548582LLU: // 99999999Pk'''''''''''''''
5164250869 {
5164350870 // variable type______ type0_____ goes out of scope
5164450871 // emitted destructur for type type______
@@ -51648,7 +50875,7 @@
5164850875 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5164950876 }
5165050877 // ACCUMULATE ARGUMENTS - END
51651- uint64_t return_to = 18446744073709548533LLU;
50878+ uint64_t return_to = 18446744073709548580LLU;
5165250879 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5165350880 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5165450881 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51657,16 +50884,16 @@
5165750884 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5165850885 break;
5165950886 }
51660- case 18446744073709548533LLU: // 99999999Oz'''''''''''''''
50887+ case 18446744073709548580LLU: // 99999999Pi'''''''''''''''
5166150888 {
5166250889 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 21
5166350890 // variable u64 INDIRECT0_ goes out of scope
5166450891 // emitted destructur for type u64
5166550892 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT0_ at 20
51666- state.addr = 18446744073709548579LLU; // 99999999Ph'''''''''''''''
50893+ state.addr = 18446744073709548626LLU; // 99999999QR'''''''''''''''
5166750894 break;
5166850895 }
51669- case 18446744073709548579LLU: // 99999999Ph'''''''''''''''
50896+ case 18446744073709548626LLU: // 99999999QR'''''''''''''''
5167050897 {
5167150898 {
5167250899 uint64_t arg = 0LLU;
@@ -51690,7 +50917,7 @@
5169050917 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5169150918 }
5169250919 // ACCUMULATE ARGUMENTS - END
51693- uint64_t return_to = 18446744073709548531LLU;
50920+ uint64_t return_to = 18446744073709548578LLU;
5169450921 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5169550922 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5169650923 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51699,12 +50926,12 @@
5169950926 state.addr = 732615645798520865LLU; // movevarref
5170050927 break;
5170150928 }
51702- case 18446744073709548531LLU: // 99999999Ox'''''''''''''''
50929+ case 18446744073709548578LLU: // 99999999Pg'''''''''''''''
5170350930 {
51704- state.addr = 18446744073709548532LLU; // 99999999Oy'''''''''''''''
50931+ state.addr = 18446744073709548579LLU; // 99999999Ph'''''''''''''''
5170550932 break;
5170650933 }
51707- case 18446744073709548532LLU: // 99999999Oy'''''''''''''''
50934+ case 18446744073709548579LLU: // 99999999Ph'''''''''''''''
5170850935 {
5170950936 {
5171050937 uint64_t arg = 0LLU;
@@ -51748,7 +50975,7 @@
5174850975 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5174950976 }
5175050977 // ACCUMULATE ARGUMENTS - END
51751- uint64_t return_to = 18446744073709548528LLU;
50978+ uint64_t return_to = 18446744073709548575LLU;
5175250979 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0));
5175350980 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5175450981 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51757,12 +50984,12 @@
5175750984 state.addr = 533581901819281408LLU; // blockif___
5175850985 break;
5175950986 }
51760- case 18446744073709548528LLU: // 99999999Ou'''''''''''''''
50987+ case 18446744073709548575LLU: // 99999999Pd'''''''''''''''
5176150988 {
51762- state.addr = 18446744073709548529LLU; // 99999999Ov'''''''''''''''
50989+ state.addr = 18446744073709548576LLU; // 99999999Pe'''''''''''''''
5176350990 break;
5176450991 }
51765- case 18446744073709548529LLU: // 99999999Ov'''''''''''''''
50992+ case 18446744073709548576LLU: // 99999999Pe'''''''''''''''
5176650993 {
5176750994 // variable u64 borrowheap goes out of scope
5176850995 // emitted destructur for type u64
@@ -51770,10 +50997,10 @@
5177050997 // variable u64 borrowsize goes out of scope
5177150998 // emitted destructur for type u64
5177250999 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference borrowsize at 21
51773- state.addr = 18446744073709548530LLU; // 99999999Ow'''''''''''''''
51000+ state.addr = 18446744073709548577LLU; // 99999999Pf'''''''''''''''
5177451001 break;
5177551002 }
51776- case 18446744073709548530LLU: // 99999999Ow'''''''''''''''
51003+ case 18446744073709548577LLU: // 99999999Pf'''''''''''''''
5177751004 {
5177851005 // ACCUMULATE ARGUMENTS - BEGIN
5177951006 {
@@ -51781,7 +51008,7 @@
5178151008 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5178251009 }
5178351010 // ACCUMULATE ARGUMENTS - END
51784- uint64_t return_to = 18446744073709548526LLU;
51011+ uint64_t return_to = 18446744073709548573LLU;
5178551012 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5178651013 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5178751014 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51790,12 +51017,12 @@
5179051017 state.addr = 839519719621918720LLU; // skipws____
5179151018 break;
5179251019 }
51793- case 18446744073709548526LLU: // 99999999Os'''''''''''''''
51020+ case 18446744073709548573LLU: // 99999999Pb'''''''''''''''
5179451021 {
51795- state.addr = 18446744073709548527LLU; // 99999999Ot'''''''''''''''
51022+ state.addr = 18446744073709548574LLU; // 99999999Pc'''''''''''''''
5179651023 break;
5179751024 }
51798- case 18446744073709548527LLU: // 99999999Ot'''''''''''''''
51025+ case 18446744073709548574LLU: // 99999999Pc'''''''''''''''
5179951026 {
5180051027 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 8LLU)), stdin);
5180151028 if('{' != (char)getchar())
@@ -51817,7 +51044,7 @@
5181751044 }
5181851045 // ACCUMULATE ARGUMENTS - BEGIN
5181951046 // ACCUMULATE ARGUMENTS - END
51820- uint64_t return_to = 18446744073709548523LLU;
51047+ uint64_t return_to = 18446744073709548570LLU;
5182151048 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
5182251049 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5182351050 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51826,12 +51053,12 @@
5182651053 state.addr = 890787671342055424LLU; // varopen___
5182751054 break;
5182851055 }
51829- case 18446744073709548523LLU: // 99999999Op'''''''''''''''
51056+ case 18446744073709548570LLU: // 99999999PZ'''''''''''''''
5183051057 {
51831- state.addr = 18446744073709548524LLU; // 99999999Oq'''''''''''''''
51058+ state.addr = 18446744073709548571LLU; // 99999999P$'''''''''''''''
5183251059 break;
5183351060 }
51834- case 18446744073709548524LLU: // 99999999Oq'''''''''''''''
51061+ case 18446744073709548571LLU: // 99999999P$'''''''''''''''
5183551062 {
5183651063 // ACCUMULATE ARGUMENTS - BEGIN
5183751064 {
@@ -51855,7 +51082,7 @@
5185551082 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5185651083 }
5185751084 // ACCUMULATE ARGUMENTS - END
51858- uint64_t return_to = 18446744073709548521LLU;
51085+ uint64_t return_to = 18446744073709548568LLU;
5185951086 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5186051087 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5186151088 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51864,12 +51091,12 @@
5186451091 state.addr = 587881357514113024LLU; // emitpar___
5186551092 break;
5186651093 }
51867- case 18446744073709548521LLU: // 99999999On'''''''''''''''
51094+ case 18446744073709548568LLU: // 99999999PX'''''''''''''''
5186851095 {
51869- state.addr = 18446744073709548522LLU; // 99999999Oo'''''''''''''''
51096+ state.addr = 18446744073709548569LLU; // 99999999PY'''''''''''''''
5187051097 break;
5187151098 }
51872- case 18446744073709548522LLU: // 99999999Oo'''''''''''''''
51099+ case 18446744073709548569LLU: // 99999999PY'''''''''''''''
5187351100 {
5187451101 // ACCUMULATE ARGUMENTS - BEGIN
5187551102 {
@@ -51893,7 +51120,7 @@
5189351120 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5189451121 }
5189551122 // ACCUMULATE ARGUMENTS - END
51896- uint64_t return_to = 18446744073709548519LLU;
51123+ uint64_t return_to = 18446744073709548566LLU;
5189751124 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5189851125 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5189951126 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51902,12 +51129,12 @@
5190251129 state.addr = 890786842582581248LLU; // varclose__
5190351130 break;
5190451131 }
51905- case 18446744073709548519LLU: // 99999999Ol'''''''''''''''
51132+ case 18446744073709548566LLU: // 99999999PV'''''''''''''''
5190651133 {
51907- state.addr = 18446744073709548520LLU; // 99999999Om'''''''''''''''
51134+ state.addr = 18446744073709548567LLU; // 99999999PW'''''''''''''''
5190851135 break;
5190951136 }
51910- case 18446744073709548520LLU: // 99999999Om'''''''''''''''
51137+ case 18446744073709548567LLU: // 99999999PW'''''''''''''''
5191151138 {
5191251139 {
5191351140 uint64_t arg = 1LLU;
@@ -51927,7 +51154,7 @@
5192751154 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5192851155 }
5192951156 // ACCUMULATE ARGUMENTS - END
51930- uint64_t return_to = 18446744073709548516LLU;
51157+ uint64_t return_to = 18446744073709548563LLU;
5193151158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5193251159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5193351160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51936,12 +51163,12 @@
5193651163 state.addr = 367395560426147840LLU; // TYPECOPY__
5193751164 break;
5193851165 }
51939- case 18446744073709548516LLU: // 99999999Oi'''''''''''''''
51166+ case 18446744073709548563LLU: // 99999999PS'''''''''''''''
5194051167 {
51941- state.addr = 18446744073709548517LLU; // 99999999Oj'''''''''''''''
51168+ state.addr = 18446744073709548564LLU; // 99999999PT'''''''''''''''
5194251169 break;
5194351170 }
51944- case 18446744073709548517LLU: // 99999999Oj'''''''''''''''
51171+ case 18446744073709548564LLU: // 99999999PT'''''''''''''''
5194551172 {
5194651173 // ACCUMULATE ARGUMENTS - BEGIN
5194751174 {
@@ -51973,7 +51200,7 @@
5197351200 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5197451201 }
5197551202 // ACCUMULATE ARGUMENTS - END
51976- uint64_t return_to = 18446744073709548514LLU;
51203+ uint64_t return_to = 18446744073709548561LLU;
5197751204 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
5197851205 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5197951206 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -51982,12 +51209,12 @@
5198251209 state.addr = 788334703205941248LLU; // pushvar___
5198351210 break;
5198451211 }
51985- case 18446744073709548514LLU: // 99999999Og'''''''''''''''
51212+ case 18446744073709548561LLU: // 99999999PQ'''''''''''''''
5198651213 {
51987- state.addr = 18446744073709548515LLU; // 99999999Oh'''''''''''''''
51214+ state.addr = 18446744073709548562LLU; // 99999999PR'''''''''''''''
5198851215 break;
5198951216 }
51990- case 18446744073709548515LLU: // 99999999Oh'''''''''''''''
51217+ case 18446744073709548562LLU: // 99999999PR'''''''''''''''
5199151218 {
5199251219 // variable type______ t_________ goes out of scope
5199351220 // emitted destructur for type type______
@@ -51997,7 +51224,7 @@
5199751224 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5199851225 }
5199951226 // ACCUMULATE ARGUMENTS - END
52000- uint64_t return_to = 18446744073709548513LLU;
51227+ uint64_t return_to = 18446744073709548560LLU;
5200151228 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5200251229 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5200351230 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52006,16 +51233,16 @@
5200651233 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5200751234 break;
5200851235 }
52009- case 18446744073709548513LLU: // 99999999Of'''''''''''''''
51236+ case 18446744073709548560LLU: // 99999999PP'''''''''''''''
5201051237 {
5201151238 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 25
5201251239 // variable u64 initialize goes out of scope
5201351240 // emitted destructur for type u64
5201451241 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 24
52015- state.addr = 18446744073709548518LLU; // 99999999Ok'''''''''''''''
51242+ state.addr = 18446744073709548565LLU; // 99999999PU'''''''''''''''
5201651243 break;
5201751244 }
52018- case 18446744073709548518LLU: // 99999999Ok'''''''''''''''
51245+ case 18446744073709548565LLU: // 99999999PU'''''''''''''''
5201951246 {
5202051247 // variable u64 mutable___ goes out of scope
5202151248 // emitted destructur for type u64
@@ -52026,21 +51253,21 @@
5202651253 // variable u64 INDIRECT__ goes out of scope
5202751254 // emitted destructur for type u64
5202851255 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 21
52029- state.addr = 18446744073709548525LLU; // 99999999Or'''''''''''''''
51256+ state.addr = 18446744073709548572LLU; // 99999999Pa'''''''''''''''
5203051257 break;
5203151258 }
52032- case 18446744073709548525LLU: // 99999999Or'''''''''''''''
51259+ case 18446744073709548572LLU: // 99999999Pa'''''''''''''''
5203351260 {
5203451261 // variable list<resdest___> results___ goes out of scope
5203551262 // emitted destructur for type list<resdest___>
52036- state.addr = 18446744073709548511LLU; // 99999999Od'''''''''''''''
51263+ state.addr = 18446744073709548558LLU; // 99999999PN'''''''''''''''
5203751264 break;
5203851265 }
52039- case 18446744073709548511LLU: // 99999999Od'''''''''''''''
51266+ case 18446744073709548558LLU: // 99999999PN'''''''''''''''
5204051267 {
5204151268 if(!*LOCAL_ACCESS(heap.data, 20LLU, 19LLU)/*list*/)
5204251269 {
52043- state.addr = 18446744073709548512LLU; // 99999999Oe'''''''''''''''
51270+ state.addr = 18446744073709548559LLU; // 99999999PO'''''''''''''''
5204451271 break;
5204551272 }
5204651273 // temporary list-element
@@ -52054,7 +51281,7 @@
5205451281 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5205551282 }
5205651283 // ACCUMULATE ARGUMENTS - END
52057- uint64_t return_to = 18446744073709548510LLU;
51284+ uint64_t return_to = 18446744073709548557LLU;
5205851285 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5205951286 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5206051287 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52063,14 +51290,14 @@
5206351290 state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
5206451291 break;
5206551292 }
52066- case 18446744073709548510LLU: // 99999999Oc'''''''''''''''
51293+ case 18446744073709548557LLU: // 99999999PM'''''''''''''''
5206751294 {
5206851295 // RELEASE temporary destructor-variable
5206951296 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21
52070- state.addr = 18446744073709548511LLU; // 99999999Od'''''''''''''''
51297+ state.addr = 18446744073709548558LLU; // 99999999PN'''''''''''''''
5207151298 break;
5207251299 }
52073- case 18446744073709548512LLU: // 99999999Oe'''''''''''''''
51300+ case 18446744073709548559LLU: // 99999999PO'''''''''''''''
5207451301 {
5207551302 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 20
5207651303 // variable type______ type1_____ goes out of scope
@@ -52081,7 +51308,7 @@
5208151308 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5208251309 }
5208351310 // ACCUMULATE ARGUMENTS - END
52084- uint64_t return_to = 18446744073709548509LLU;
51311+ uint64_t return_to = 18446744073709548556LLU;
5208551312 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5208651313 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5208751314 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52090,7 +51317,7 @@
5209051317 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5209151318 break;
5209251319 }
52093- case 18446744073709548509LLU: // 99999999Ob'''''''''''''''
51320+ case 18446744073709548556LLU: // 99999999PL'''''''''''''''
5209451321 {
5209551322 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 19
5209651323 // variable u64 elemid____ goes out of scope
@@ -52156,10 +51383,10 @@
5215651383 };
5215751384 *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = arg;
5215851385 }
52159- state.addr = 18446744073709548508LLU; // 99999999Oa'''''''''''''''
51386+ state.addr = 18446744073709548555LLU; // 99999999PK'''''''''''''''
5216051387 break;
5216151388 }
52162- case 18446744073709548508LLU: // 99999999Oa'''''''''''''''
51389+ case 18446744073709548555LLU: // 99999999PK'''''''''''''''
5216351390 {
5216451391 {
5216551392 uint64_t arg = 0LLU;
@@ -52255,7 +51482,7 @@
5225551482 LOCAL_PUSH_MOVE(&heap, 17LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5225651483 }
5225751484 // ACCUMULATE ARGUMENTS - END
52258- uint64_t return_to = 18446744073709548505LLU;
51485+ uint64_t return_to = 18446744073709548552LLU;
5225951486 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/*address of closure-in-construction*/, 0));
5226051487 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5226151488 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52264,12 +51491,12 @@
5226451491 state.addr = 787472336050047842LLU; // procpararg
5226551492 break;
5226651493 }
52267- case 18446744073709548505LLU: // 99999999OY'''''''''''''''
51494+ case 18446744073709548552LLU: // 99999999PH'''''''''''''''
5226851495 {
52269- state.addr = 18446744073709548506LLU; // 99999999OZ'''''''''''''''
51496+ state.addr = 18446744073709548553LLU; // 99999999PI'''''''''''''''
5227051497 break;
5227151498 }
52272- case 18446744073709548506LLU: // 99999999OZ'''''''''''''''
51499+ case 18446744073709548553LLU: // 99999999PI'''''''''''''''
5227351500 {
5227451501 // variable u64 INDIRECT__ goes out of scope
5227551502 // emitted destructur for type u64
@@ -52277,10 +51504,10 @@
5227751504 // variable u64 idx_______ goes out of scope
5227851505 // emitted destructur for type u64
5227951506 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 25
52280- state.addr = 18446744073709548507LLU; // 99999999O$'''''''''''''''
51507+ state.addr = 18446744073709548554LLU; // 99999999PJ'''''''''''''''
5228151508 break;
5228251509 }
52283- case 18446744073709548507LLU: // 99999999O$'''''''''''''''
51510+ case 18446744073709548554LLU: // 99999999PJ'''''''''''''''
5228451511 {
5228551512 {
5228651513 uint64_t arg = 548487458505883648LLU;
@@ -52304,7 +51531,7 @@
5230451531 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5230551532 }
5230651533 // ACCUMULATE ARGUMENTS - END
52307- uint64_t return_to = 18446744073709548502LLU;
51534+ uint64_t return_to = 18446744073709548549LLU;
5230851535 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5230951536 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5231051537 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52313,12 +51540,12 @@
5231351540 state.addr = 861504774606571689LLU; // typeassign
5231451541 break;
5231551542 }
52316- case 18446744073709548502LLU: // 99999999OV'''''''''''''''
51543+ case 18446744073709548549LLU: // 99999999PE'''''''''''''''
5231751544 {
52318- state.addr = 18446744073709548503LLU; // 99999999OW'''''''''''''''
51545+ state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
5231951546 break;
5232051547 }
52321- case 18446744073709548503LLU: // 99999999OW'''''''''''''''
51548+ case 18446744073709548550LLU: // 99999999PF'''''''''''''''
5232251549 {
5232351550 {
5232451551 uint64_t arg = 0LLU;
@@ -52351,7 +51578,7 @@
5235151578 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5235251579 }
5235351580 // ACCUMULATE ARGUMENTS - END
52354- uint64_t return_to = 18446744073709548499LLU;
51581+ uint64_t return_to = 18446744073709548546LLU;
5235551582 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
5235651583 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5235751584 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52360,17 +51587,17 @@
5236051587 state.addr = 734295547157569536LLU; // mutcheck__
5236151588 break;
5236251589 }
52363- case 18446744073709548499LLU: // 99999999OS'''''''''''''''
51590+ case 18446744073709548546LLU: // 99999999PB'''''''''''''''
5236451591 {
52365- state.addr = 18446744073709548500LLU; // 99999999OT'''''''''''''''
51592+ state.addr = 18446744073709548547LLU; // 99999999PC'''''''''''''''
5236651593 break;
5236751594 }
52368- case 18446744073709548500LLU: // 99999999OT'''''''''''''''
51595+ case 18446744073709548547LLU: // 99999999PC'''''''''''''''
5236951596 {
52370- state.addr = 18446744073709548501LLU; // 99999999OU'''''''''''''''
51597+ state.addr = 18446744073709548548LLU; // 99999999PD'''''''''''''''
5237151598 break;
5237251599 }
52373- case 18446744073709548501LLU: // 99999999OU'''''''''''''''
51600+ case 18446744073709548548LLU: // 99999999PD'''''''''''''''
5237451601 {
5237551602 // variable u64 revparnr__ goes out of scope
5237651603 // emitted destructur for type u64
@@ -52378,10 +51605,10 @@
5237851605 // variable u64 info______ goes out of scope
5237951606 // emitted destructur for type u64
5238051607 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 25
52381- state.addr = 18446744073709548504LLU; // 99999999OX'''''''''''''''
51608+ state.addr = 18446744073709548551LLU; // 99999999PG'''''''''''''''
5238251609 break;
5238351610 }
52384- case 18446744073709548504LLU: // 99999999OX'''''''''''''''
51611+ case 18446744073709548551LLU: // 99999999PG'''''''''''''''
5238551612 {
5238651613 // variable u64 parameter_ goes out of scope
5238751614 // emitted destructur for type u64
@@ -52400,7 +51627,7 @@
5240051627 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5240151628 }
5240251629 // ACCUMULATE ARGUMENTS - END
52403- uint64_t return_to = 18446744073709548498LLU;
51630+ uint64_t return_to = 18446744073709548545LLU;
5240451631 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5240551632 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5240651633 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52409,7 +51636,7 @@
5240951636 state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
5241051637 break;
5241151638 }
52412- case 18446744073709548498LLU: // 99999999OR'''''''''''''''
51639+ case 18446744073709548545LLU: // 99999999PA'''''''''''''''
5241351640 {
5241451641 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typearg___ at 21
5241551642 // parameter-reference u64 defrs_____ goes out of scope
@@ -52472,7 +51699,7 @@
5247251699 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5247351700 }
5247451701 // ACCUMULATE ARGUMENTS - END
52475- uint64_t return_to = 18446744073709548496LLU;
51702+ uint64_t return_to = 18446744073709548543LLU;
5247651703 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5247751704 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5247851705 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52481,17 +51708,17 @@
5248151708 state.addr = 517555565476695680LLU; // assertu64_
5248251709 break;
5248351710 }
52484- case 18446744073709548496LLU: // 99999999OP'''''''''''''''
51711+ case 18446744073709548543LLU: // 99999999O9'''''''''''''''
5248551712 {
52486- state.addr = 18446744073709548497LLU; // 99999999OQ'''''''''''''''
51713+ state.addr = 18446744073709548544LLU; // 99999999P_'''''''''''''''
5248751714 break;
5248851715 }
52489- case 18446744073709548497LLU: // 99999999OQ'''''''''''''''
51716+ case 18446744073709548544LLU: // 99999999P_'''''''''''''''
5249051717 {
52491- state.addr = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU)) ? 18446744073709548495LLU : 18446744073709548494LLU;
51718+ state.addr = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU)) ? 18446744073709548542LLU : 18446744073709548541LLU;
5249251719 break;
5249351720 }
52494- case 18446744073709548495LLU: // 99999999OO'''''''''''''''
51721+ case 18446744073709548542LLU: // 99999999O8'''''''''''''''
5249551722 {
5249651723 fprintf(stderr, "%s", "can't assign value ");
5249751724 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52500,7 +51727,7 @@
5250051727 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5250151728 }
5250251729 // ACCUMULATE ARGUMENTS - END
52503- uint64_t return_to = 18446744073709548492LLU;
51730+ uint64_t return_to = 18446744073709548539LLU;
5250451731 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5250551732 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5250651733 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52509,12 +51736,12 @@
5250951736 state.addr = 819847183517274112LLU; // reportnr__
5251051737 break;
5251151738 }
52512- case 18446744073709548492LLU: // 99999999OL'''''''''''''''
51739+ case 18446744073709548539LLU: // 99999999O5'''''''''''''''
5251351740 {
52514- state.addr = 18446744073709548493LLU; // 99999999OM'''''''''''''''
51741+ state.addr = 18446744073709548540LLU; // 99999999O6'''''''''''''''
5251551742 break;
5251651743 }
52517- case 18446744073709548493LLU: // 99999999OM'''''''''''''''
51744+ case 18446744073709548540LLU: // 99999999O6'''''''''''''''
5251851745 {
5251951746 fprintf(stderr, "%s", " to reference-parameter ");
5252051747 // ACCUMULATE ARGUMENTS - BEGIN
@@ -52523,7 +51750,7 @@
5252351750 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5252451751 }
5252551752 // ACCUMULATE ARGUMENTS - END
52526- uint64_t return_to = 18446744073709548490LLU;
51753+ uint64_t return_to = 18446744073709548537LLU;
5252751754 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5252851755 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5252951756 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -52532,21 +51759,21 @@
5253251759 state.addr = 819847183517274112LLU; // reportnr__
5253351760 break;
5253451761 }
52535- case 18446744073709548490LLU: // 99999999OJ'''''''''''''''
51762+ case 18446744073709548537LLU: // 99999999O3'''''''''''''''
5253651763 {
52537- state.addr = 18446744073709548491LLU; // 99999999OK'''''''''''''''
51764+ state.addr = 18446744073709548538LLU; // 99999999O4'''''''''''''''
5253851765 break;
5253951766 }
52540- case 18446744073709548491LLU: // 99999999OK'''''''''''''''
51767+ case 18446744073709548538LLU: // 99999999O4'''''''''''''''
5254151768 {
5254251769 {
5254351770 fprintf(stderr, "%s\n", "");
5254451771 exit(-1);
5254551772 }
52546- state.addr = 18446744073709548494LLU; // 99999999ON'''''''''''''''
51773+ state.addr = 18446744073709548541LLU; // 99999999O7'''''''''''''''
5254751774 break;
5254851775 }
52549- case 18446744073709548494LLU: // 99999999ON'''''''''''''''
51776+ case 18446744073709548541LLU: // 99999999O7'''''''''''''''
5255051777