OSDN > Find Software > Software Development > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	923 (tree)
Time	2020-02-12 05:08:28
Author	jakobthomsen

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 @@
44106	44106	}
44107	44107	break;
44108	44108	}
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		- }
44882	44109	case 515555125197130432LLU: // allocheap_
44883	44110	{
44884	44111	{

		@@ -44903,7 +44130,7 @@
44903	44130	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44904	44131	}
44905	44132	// ACCUMULATE ARGUMENTS - END
44906		- uint64_t return_to = 18446744073709548982LLU;
	44133	+ uint64_t return_to = 18446744073709549029LLU;
44907	44134	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
44908	44135	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44909	44136	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44912,12 +44139,12 @@
44912	44139	state.addr = 375116000798050091LLU; // TypeOnHeap
44913	44140	break;
44914	44141	}
44915		- case 18446744073709548982LLU: // 99999999V0'''''''''''''''
	44142	+ case 18446744073709549029LLU: // 99999999Wj'''''''''''''''
44916	44143	{
44917		- state.addr = 18446744073709548983LLU; // 99999999V1'''''''''''''''
	44144	+ state.addr = 18446744073709549030LLU; // 99999999Wk'''''''''''''''
44918	44145	break;
44919	44146	}
44920		- case 18446744073709548983LLU: // 99999999V1'''''''''''''''
	44147	+ case 18446744073709549030LLU: // 99999999Wk'''''''''''''''
44921	44148	{
44922	44149	{
44923	44150	uint64_t arg = 0LLU;

		@@ -44924,10 +44151,10 @@
44924	44151	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
44925	44152	}
44926	44153	/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;
44928	44155	break;
44929	44156	}
44930		- case 18446744073709548981LLU: // 99999999Vz'''''''''''''''
	44157	+ case 18446744073709549028LLU: // 99999999Wi'''''''''''''''
44931	44158	{
44932	44159	// ACCUMULATE ARGUMENTS - BEGIN
44933	44160	{

		@@ -44935,7 +44162,7 @@
44935	44162	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44936	44163	}
44937	44164	// ACCUMULATE ARGUMENTS - END
44938		- uint64_t return_to = 18446744073709548978LLU;
	44165	+ uint64_t return_to = 18446744073709549025LLU;
44939	44166	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44940	44167	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44941	44168	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44944,12 +44171,12 @@
44944	44171	state.addr = 819847183515949359LLU; // reportinit
44945	44172	break;
44946	44173	}
44947		- case 18446744073709548978LLU: // 99999999Vw'''''''''''''''
	44174	+ case 18446744073709549025LLU: // 99999999Wf'''''''''''''''
44948	44175	{
44949		- state.addr = 18446744073709548979LLU; // 99999999Vx'''''''''''''''
	44176	+ state.addr = 18446744073709549026LLU; // 99999999Wg'''''''''''''''
44950	44177	break;
44951	44178	}
44952		- case 18446744073709548979LLU: // 99999999Vx'''''''''''''''
	44179	+ case 18446744073709549026LLU: // 99999999Wg'''''''''''''''
44953	44180	{
44954	44181	fprintf(stderr, "%s", "out of heap allocating ");
44955	44182	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -44958,7 +44185,7 @@
44958	44185	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44959	44186	}
44960	44187	// ACCUMULATE ARGUMENTS - END
44961		- uint64_t return_to = 18446744073709548976LLU;
	44188	+ uint64_t return_to = 18446744073709549023LLU;
44962	44189	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44963	44190	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44964	44191	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44967,12 +44194,12 @@
44967	44194	state.addr = 819847183518878432LLU; // reporttype
44968	44195	break;
44969	44196	}
44970		- case 18446744073709548976LLU: // 99999999Vu'''''''''''''''
	44197	+ case 18446744073709549023LLU: // 99999999Wd'''''''''''''''
44971	44198	{
44972		- state.addr = 18446744073709548977LLU; // 99999999Vv'''''''''''''''
	44199	+ state.addr = 18446744073709549024LLU; // 99999999We'''''''''''''''
44973	44200	break;
44974	44201	}
44975		- case 18446744073709548977LLU: // 99999999Vv'''''''''''''''
	44202	+ case 18446744073709549024LLU: // 99999999We'''''''''''''''
44976	44203	{
44977	44204	fprintf(stderr, "%s", " ");
44978	44205	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 3LLU)));

		@@ -44983,7 +44210,7 @@
44983	44210	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44984	44211	}
44985	44212	// ACCUMULATE ARGUMENTS - END
44986		- uint64_t return_to = 18446744073709548974LLU;
	44213	+ uint64_t return_to = 18446744073709549021LLU;
44987	44214	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44988	44215	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44989	44216	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44992,12 +44219,12 @@
44992	44219	state.addr = 819847183517274112LLU; // reportnr__
44993	44220	break;
44994	44221	}
44995		- case 18446744073709548974LLU: // 99999999Vs'''''''''''''''
	44222	+ case 18446744073709549021LLU: // 99999999Wb'''''''''''''''
44996	44223	{
44997		- state.addr = 18446744073709548975LLU; // 99999999Vt'''''''''''''''
	44224	+ state.addr = 18446744073709549022LLU; // 99999999Wc'''''''''''''''
44998	44225	break;
44999	44226	}
45000		- case 18446744073709548975LLU: // 99999999Vt'''''''''''''''
	44227	+ case 18446744073709549022LLU: // 99999999Wc'''''''''''''''
45001	44228	{
45002	44229	fprintf(stderr, "%s", " but remaining heap-size is ");
45003	44230	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45006,7 +44233,7 @@
45006	44233	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45007	44234	}
45008	44235	// ACCUMULATE ARGUMENTS - END
45009		- uint64_t return_to = 18446744073709548972LLU;
	44236	+ uint64_t return_to = 18446744073709549019LLU;
45010	44237	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45011	44238	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45012	44239	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45015,21 +44242,21 @@
45015	44242	state.addr = 819847183517274112LLU; // reportnr__
45016	44243	break;
45017	44244	}
45018		- case 18446744073709548972LLU: // 99999999Vq'''''''''''''''
	44245	+ case 18446744073709549019LLU: // 99999999W$'''''''''''''''
45019	44246	{
45020		- state.addr = 18446744073709548973LLU; // 99999999Vr'''''''''''''''
	44247	+ state.addr = 18446744073709549020LLU; // 99999999Wa'''''''''''''''
45021	44248	break;
45022	44249	}
45023		- case 18446744073709548973LLU: // 99999999Vr'''''''''''''''
	44250	+ case 18446744073709549020LLU: // 99999999Wa'''''''''''''''
45024	44251	{
45025	44252	{
45026	44253	fprintf(stderr, "%s\n", "");
45027	44254	exit(-1);
45028	44255	}
45029		- state.addr = 18446744073709548980LLU; // 99999999Vy'''''''''''''''
	44256	+ state.addr = 18446744073709549027LLU; // 99999999Wh'''''''''''''''
45030	44257	break;
45031	44258	}
45032		- case 18446744073709548980LLU: // 99999999Vy'''''''''''''''
	44259	+ case 18446744073709549027LLU: // 99999999Wh'''''''''''''''
45033	44260	{
45034	44261	/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);
45035	44262	// variable u64 outofheap_ goes out of scope

		@@ -45082,10 +44309,10 @@
45082	44309	};
45083	44310	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = arg;
45084	44311	}
45085		- state.addr = 18446744073709548971LLU; // 99999999Vp'''''''''''''''
	44312	+ state.addr = 18446744073709549018LLU; // 99999999WZ'''''''''''''''
45086	44313	break;
45087	44314	}
45088		- case 18446744073709548971LLU: // 99999999Vp'''''''''''''''
	44315	+ case 18446744073709549018LLU: // 99999999WZ'''''''''''''''
45089	44316	{
45090	44317	{
45091	44318	uint64_t arg = 0LLU;

		@@ -45157,7 +44384,7 @@
45157	44384	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45158	44385	}
45159	44386	// ACCUMULATE ARGUMENTS - END
45160		- uint64_t return_to = 18446744073709548967LLU;
	44387	+ uint64_t return_to = 18446744073709549014LLU;
45161	44388	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
45162	44389	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45163	44390	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45166,20 +44393,20 @@
45166	44393	state.addr = 604790753280317473LLU; // findvarref
45167	44394	break;
45168	44395	}
45169		- case 18446744073709548967LLU: // 99999999Vl'''''''''''''''
	44396	+ case 18446744073709549014LLU: // 99999999WV'''''''''''''''
45170	44397	{
45171		- state.addr = 18446744073709548968LLU; // 99999999Vm'''''''''''''''
	44398	+ state.addr = 18446744073709549015LLU; // 99999999WW'''''''''''''''
45172	44399	break;
45173	44400	}
45174		- case 18446744073709548968LLU: // 99999999Vm'''''''''''''''
	44401	+ case 18446744073709549015LLU: // 99999999WW'''''''''''''''
45175	44402	{
45176	44403	// variable u64 optelem___ goes out of scope
45177	44404	// emitted destructur for type u64
45178	44405	(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'''''''''''''''
45180	44407	break;
45181	44408	}
45182		- case 18446744073709548969LLU: // 99999999Vn'''''''''''''''
	44409	+ case 18446744073709549016LLU: // 99999999WX'''''''''''''''
45183	44410	{
45184	44411	// ACCUMULATE ARGUMENTS - BEGIN
45185	44412	{

		@@ -45203,7 +44430,7 @@
45203	44430	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45204	44431	}
45205	44432	// ACCUMULATE ARGUMENTS - END
45206		- uint64_t return_to = 18446744073709548965LLU;
	44433	+ uint64_t return_to = 18446744073709549012LLU;
45207	44434	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
45208	44435	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45209	44436	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45212,12 +44439,12 @@
45212	44439	state.addr = 587881357514113024LLU; // emitpar___
45213	44440	break;
45214	44441	}
45215		- case 18446744073709548965LLU: // 99999999Vj'''''''''''''''
	44442	+ case 18446744073709549012LLU: // 99999999WT'''''''''''''''
45216	44443	{
45217		- state.addr = 18446744073709548966LLU; // 99999999Vk'''''''''''''''
	44444	+ state.addr = 18446744073709549013LLU; // 99999999WU'''''''''''''''
45218	44445	break;
45219	44446	}
45220		- case 18446744073709548966LLU: // 99999999Vk'''''''''''''''
	44447	+ case 18446744073709549013LLU: // 99999999WU'''''''''''''''
45221	44448	{
45222	44449	// ACCUMULATE ARGUMENTS - BEGIN
45223	44450	{

		@@ -45225,7 +44452,7 @@
45225	44452	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45226	44453	}
45227	44454	// ACCUMULATE ARGUMENTS - END
45228		- uint64_t return_to = 18446744073709548963LLU;
	44455	+ uint64_t return_to = 18446744073709549010LLU;
45229	44456	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45230	44457	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45231	44458	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45234,12 +44461,12 @@
45234	44461	state.addr = 839519719621918720LLU; // skipws____
45235	44462	break;
45236	44463	}
45237		- case 18446744073709548963LLU: // 99999999Vh'''''''''''''''
	44464	+ case 18446744073709549010LLU: // 99999999WR'''''''''''''''
45238	44465	{
45239		- state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
	44466	+ state.addr = 18446744073709549011LLU; // 99999999WS'''''''''''''''
45240	44467	break;
45241	44468	}
45242		- case 18446744073709548964LLU: // 99999999Vi'''''''''''''''
	44469	+ case 18446744073709549011LLU: // 99999999WS'''''''''''''''
45243	44470	{
45244	44471	*LOCAL_ACCESS(heap.data, 19LLU, 11LLU) = 46LLU;
45245	44472

		@@ -45261,7 +44488,7 @@
45261	44488	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45262	44489	}
45263	44490	// ACCUMULATE ARGUMENTS - END
45264		- uint64_t return_to = 18446744073709548961LLU;
	44491	+ uint64_t return_to = 18446744073709549008LLU;
45265	44492	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
45266	44493	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45267	44494	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45270,17 +44497,17 @@
45270	44497	state.addr = 728666047794575267LLU; // matchoptch
45271	44498	break;
45272	44499	}
45273		- case 18446744073709548961LLU: // 99999999Vf'''''''''''''''
	44500	+ case 18446744073709549008LLU: // 99999999WP'''''''''''''''
45274	44501	{
45275		- state.addr = 18446744073709548962LLU; // 99999999Vg'''''''''''''''
	44502	+ state.addr = 18446744073709549009LLU; // 99999999WQ'''''''''''''''
45276	44503	break;
45277	44504	}
45278		- case 18446744073709548962LLU: // 99999999Vg'''''''''''''''
	44505	+ case 18446744073709549009LLU: // 99999999WQ'''''''''''''''
45279	44506	{
45280		- state.addr = /isdot_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548960LLU : 18446744073709548959LLU;
	44507	+ state.addr = /isdot_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709549007LLU : 18446744073709549006LLU;
45281	44508	break;
45282	44509	}
45283		- case 18446744073709548960LLU: // 99999999Ve'''''''''''''''
	44510	+ case 18446744073709549007LLU: // 99999999WO'''''''''''''''
45284	44511	{
45285	44512	// ACCUMULATE ARGUMENTS - BEGIN
45286	44513	{

		@@ -45288,7 +44515,7 @@
45288	44515	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45289	44516	}
45290	44517	// ACCUMULATE ARGUMENTS - END
45291		- uint64_t return_to = 18446744073709548957LLU;
	44518	+ uint64_t return_to = 18446744073709549004LLU;
45292	44519	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45293	44520	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45294	44521	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45297,12 +44524,12 @@
45297	44524	state.addr = 819847183515949359LLU; // reportinit
45298	44525	break;
45299	44526	}
45300		- case 18446744073709548957LLU: // 99999999Vb'''''''''''''''
	44527	+ case 18446744073709549004LLU: // 99999999WL'''''''''''''''
45301	44528	{
45302		- state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
	44529	+ state.addr = 18446744073709549005LLU; // 99999999WM'''''''''''''''
45303	44530	break;
45304	44531	}
45305		- case 18446744073709548958LLU: // 99999999Vc'''''''''''''''
	44532	+ case 18446744073709549005LLU: // 99999999WM'''''''''''''''
45306	44533	{
45307	44534	fprintf(stderr, "%s", "can't move element (calling constructor ");
45308	44535	printid(stderr, /constrid__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 1LLU)));

		@@ -45311,18 +44538,18 @@
45311	44538	fprintf(stderr, "%s\n", "");
45312	44539	exit(-1);
45313	44540	}
45314		- state.addr = 18446744073709548959LLU; // 99999999Vd'''''''''''''''
	44541	+ state.addr = 18446744073709549006LLU; // 99999999WN'''''''''''''''
45315	44542	break;
45316	44543	}
45317		- case 18446744073709548959LLU: // 99999999Vd'''''''''''''''
	44544	+ case 18446744073709549006LLU: // 99999999WN'''''''''''''''
45318	44545	{
45319	44546	// variable u64 isdot_____ goes out of scope
45320	44547	// emitted destructur for type u64
45321	44548	(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'''''''''''''''
45323	44550	break;
45324	44551	}
45325		- case 18446744073709548970LLU: // 99999999Vo'''''''''''''''
	44552	+ case 18446744073709549017LLU: // 99999999WY'''''''''''''''
45326	44553	{
45327	44554	{
45328	44555	uint64_t arg = 0LLU;

		@@ -45342,7 +44569,7 @@
45342	44569	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45343	44570	}
45344	44571	// ACCUMULATE ARGUMENTS - END
45345		- uint64_t return_to = 18446744073709548954LLU;
	44572	+ uint64_t return_to = 18446744073709549001LLU;
45346	44573	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
45347	44574	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45348	44575	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45351,12 +44578,12 @@
45351	44578	state.addr = 861504787186880512LLU; // typemain__
45352	44579	break;
45353	44580	}
45354		- case 18446744073709548954LLU: // 99999999VZ'''''''''''''''
	44581	+ case 18446744073709549001LLU: // 99999999WI'''''''''''''''
45355	44582	{
45356		- state.addr = 18446744073709548955LLU; // 99999999V$'''''''''''''''
	44583	+ state.addr = 18446744073709549002LLU; // 99999999WJ'''''''''''''''
45357	44584	break;
45358	44585	}
45359		- case 18446744073709548955LLU: // 99999999V$'''''''''''''''
	44586	+ case 18446744073709549002LLU: // 99999999WJ'''''''''''''''
45360	44587	{
45361	44588	{
45362	44589	uint64_t arg = 0LLU;

		@@ -45372,7 +44599,7 @@
45372	44599	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45373	44600	}
45374	44601	// ACCUMULATE ARGUMENTS - END
45375		- uint64_t return_to = 18446744073709548952LLU;
	44602	+ uint64_t return_to = 18446744073709548999LLU;
45376	44603	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
45377	44604	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45378	44605	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45381,12 +44608,12 @@
45381	44608	state.addr = 861504793962872832LLU; // typesub___
45382	44609	break;
45383	44610	}
45384		- case 18446744073709548952LLU: // 99999999VX'''''''''''''''
	44611	+ case 18446744073709548999LLU: // 99999999WG'''''''''''''''
45385	44612	{
45386		- state.addr = 18446744073709548953LLU; // 99999999VY'''''''''''''''
	44613	+ state.addr = 18446744073709549000LLU; // 99999999WH'''''''''''''''
45387	44614	break;
45388	44615	}
45389		- case 18446744073709548953LLU: // 99999999VY'''''''''''''''
	44616	+ case 18446744073709549000LLU: // 99999999WH'''''''''''''''
45390	44617	{
45391	44618	{
45392	44619	uint64_t arg = 0LLU;

		@@ -45402,7 +44629,7 @@
45402	44629	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45403	44630	}
45404	44631	// ACCUMULATE ARGUMENTS - END
45405		- uint64_t return_to = 18446744073709548950LLU;
	44632	+ uint64_t return_to = 18446744073709548997LLU;
45406	44633	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
45407	44634	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45408	44635	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45411,12 +44638,12 @@
45411	44638	state.addr = 861504787186880512LLU; // typemain__
45412	44639	break;
45413	44640	}
45414		- case 18446744073709548950LLU: // 99999999VV'''''''''''''''
	44641	+ case 18446744073709548997LLU: // 99999999WE'''''''''''''''
45415	44642	{
45416		- state.addr = 18446744073709548951LLU; // 99999999VW'''''''''''''''
	44643	+ state.addr = 18446744073709548998LLU; // 99999999WF'''''''''''''''
45417	44644	break;
45418	44645	}
45419		- case 18446744073709548951LLU: // 99999999VW'''''''''''''''
	44646	+ case 18446744073709548998LLU: // 99999999WF'''''''''''''''
45420	44647	{
45421	44648	{
45422	44649	uint64_t arg = 0LLU;

		@@ -45432,7 +44659,7 @@
45432	44659	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45433	44660	}
45434	44661	// ACCUMULATE ARGUMENTS - END
45435		- uint64_t return_to = 18446744073709548948LLU;
	44662	+ uint64_t return_to = 18446744073709548995LLU;
45436	44663	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
45437	44664	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45438	44665	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45441,18 +44668,18 @@
45441	44668	state.addr = 861504793962872832LLU; // typesub___
45442	44669	break;
45443	44670	}
45444		- case 18446744073709548948LLU: // 99999999VT'''''''''''''''
	44671	+ case 18446744073709548995LLU: // 99999999WC'''''''''''''''
45445	44672	{
45446		- state.addr = 18446744073709548949LLU; // 99999999VU'''''''''''''''
	44673	+ state.addr = 18446744073709548996LLU; // 99999999WD'''''''''''''''
45447	44674	break;
45448	44675	}
45449		- case 18446744073709548949LLU: // 99999999VU'''''''''''''''
	44676	+ case 18446744073709548996LLU: // 99999999WD'''''''''''''''
45450	44677	{
45451	44678	/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;
45453	44680	break;
45454	44681	}
45455		- case 18446744073709548947LLU: // 99999999VS'''''''''''''''
	44682	+ case 18446744073709548994LLU: // 99999999WB'''''''''''''''
45456	44683	{
45457	44684	// ACCUMULATE ARGUMENTS - BEGIN
45458	44685	{

		@@ -45460,7 +44687,7 @@
45460	44687	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45461	44688	}
45462	44689	// ACCUMULATE ARGUMENTS - END
45463		- uint64_t return_to = 18446744073709548944LLU;
	44690	+ uint64_t return_to = 18446744073709548991LLU;
45464	44691	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45465	44692	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45466	44693	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45469,12 +44696,12 @@
45469	44696	state.addr = 819847183515949359LLU; // reportinit
45470	44697	break;
45471	44698	}
45472		- case 18446744073709548944LLU: // 99999999VP'''''''''''''''
	44699	+ case 18446744073709548991LLU: // 99999999V9'''''''''''''''
45473	44700	{
45474		- state.addr = 18446744073709548945LLU; // 99999999VQ'''''''''''''''
	44701	+ state.addr = 18446744073709548992LLU; // 99999999W_'''''''''''''''
45475	44702	break;
45476	44703	}
45477		- case 18446744073709548945LLU: // 99999999VQ'''''''''''''''
	44704	+ case 18446744073709548992LLU: // 99999999W_'''''''''''''''
45478	44705	{
45479	44706	fprintf(stderr, "%s", "[let] ");
45480	44707	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45483,7 +44710,7 @@
45483	44710	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45484	44711	}
45485	44712	// ACCUMULATE ARGUMENTS - END
45486		- uint64_t return_to = 18446744073709548942LLU;
	44713	+ uint64_t return_to = 18446744073709548989LLU;
45487	44714	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45488	44715	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45489	44716	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45492,12 +44719,12 @@
45492	44719	state.addr = 819847183518878432LLU; // reporttype
45493	44720	break;
45494	44721	}
45495		- case 18446744073709548942LLU: // 99999999VN'''''''''''''''
	44722	+ case 18446744073709548989LLU: // 99999999V7'''''''''''''''
45496	44723	{
45497		- state.addr = 18446744073709548943LLU; // 99999999VO'''''''''''''''
	44724	+ state.addr = 18446744073709548990LLU; // 99999999V8'''''''''''''''
45498	44725	break;
45499	44726	}
45500		- case 18446744073709548943LLU: // 99999999VO'''''''''''''''
	44727	+ case 18446744073709548990LLU: // 99999999V8'''''''''''''''
45501	44728	{
45502	44729	fprintf(stderr, "%s", ": ");
45503	44730	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45506,7 +44733,7 @@
45506	44733	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45507	44734	}
45508	44735	// ACCUMULATE ARGUMENTS - END
45509		- uint64_t return_to = 18446744073709548940LLU;
	44736	+ uint64_t return_to = 18446744073709548987LLU;
45510	44737	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45511	44738	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45512	44739	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45515,12 +44742,12 @@
45515	44742	state.addr = 819847183518878432LLU; // reporttype
45516	44743	break;
45517	44744	}
45518		- case 18446744073709548940LLU: // 99999999VL'''''''''''''''
	44745	+ case 18446744073709548987LLU: // 99999999V5'''''''''''''''
45519	44746	{
45520		- state.addr = 18446744073709548941LLU; // 99999999VM'''''''''''''''
	44747	+ state.addr = 18446744073709548988LLU; // 99999999V6'''''''''''''''
45521	44748	break;
45522	44749	}
45523		- case 18446744073709548941LLU: // 99999999VM'''''''''''''''
	44750	+ case 18446744073709548988LLU: // 99999999V6'''''''''''''''
45524	44751	{
45525	44752	fprintf(stderr, "%s", " != ");
45526	44753	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45529,7 +44756,7 @@
45529	44756	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45530	44757	}
45531	44758	// ACCUMULATE ARGUMENTS - END
45532		- uint64_t return_to = 18446744073709548938LLU;
	44759	+ uint64_t return_to = 18446744073709548985LLU;
45533	44760	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45534	44761	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45535	44762	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45538,27 +44765,27 @@
45538	44765	state.addr = 819847183518878432LLU; // reporttype
45539	44766	break;
45540	44767	}
45541		- case 18446744073709548938LLU: // 99999999VJ'''''''''''''''
	44768	+ case 18446744073709548985LLU: // 99999999V3'''''''''''''''
45542	44769	{
45543		- state.addr = 18446744073709548939LLU; // 99999999VK'''''''''''''''
	44770	+ state.addr = 18446744073709548986LLU; // 99999999V4'''''''''''''''
45544	44771	break;
45545	44772	}
45546		- case 18446744073709548939LLU: // 99999999VK'''''''''''''''
	44773	+ case 18446744073709548986LLU: // 99999999V4'''''''''''''''
45547	44774	{
45548	44775	{
45549	44776	fprintf(stderr, "%s\n", "");
45550	44777	exit(-1);
45551	44778	}
45552		- state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
	44779	+ state.addr = 18446744073709548993LLU; // 99999999WA'''''''''''''''
45553	44780	break;
45554	44781	}
45555		- case 18446744073709548946LLU: // 99999999VR'''''''''''''''
	44782	+ case 18446744073709548993LLU: // 99999999WA'''''''''''''''
45556	44783	{
45557	44784	/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;
45559	44786	break;
45560	44787	}
45561		- case 18446744073709548937LLU: // 99999999VI'''''''''''''''
	44788	+ case 18446744073709548984LLU: // 99999999V2'''''''''''''''
45562	44789	{
45563	44790	// ACCUMULATE ARGUMENTS - BEGIN
45564	44791	{

		@@ -45566,7 +44793,7 @@
45566	44793	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45567	44794	}
45568	44795	// ACCUMULATE ARGUMENTS - END
45569		- uint64_t return_to = 18446744073709548934LLU;
	44796	+ uint64_t return_to = 18446744073709548981LLU;
45570	44797	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45571	44798	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45572	44799	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45575,12 +44802,12 @@
45575	44802	state.addr = 819847183515949359LLU; // reportinit
45576	44803	break;
45577	44804	}
45578		- case 18446744073709548934LLU: // 99999999VF'''''''''''''''
	44805	+ case 18446744073709548981LLU: // 99999999Vz'''''''''''''''
45579	44806	{
45580		- state.addr = 18446744073709548935LLU; // 99999999VG'''''''''''''''
	44807	+ state.addr = 18446744073709548982LLU; // 99999999V0'''''''''''''''
45581	44808	break;
45582	44809	}
45583		- case 18446744073709548935LLU: // 99999999VG'''''''''''''''
	44810	+ case 18446744073709548982LLU: // 99999999V0'''''''''''''''
45584	44811	{
45585	44812	fprintf(stderr, "%s", "[let] ");
45586	44813	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45589,7 +44816,7 @@
45589	44816	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45590	44817	}
45591	44818	// ACCUMULATE ARGUMENTS - END
45592		- uint64_t return_to = 18446744073709548932LLU;
	44819	+ uint64_t return_to = 18446744073709548979LLU;
45593	44820	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45594	44821	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45595	44822	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45598,12 +44825,12 @@
45598	44825	state.addr = 819847183518878432LLU; // reporttype
45599	44826	break;
45600	44827	}
45601		- case 18446744073709548932LLU: // 99999999VD'''''''''''''''
	44828	+ case 18446744073709548979LLU: // 99999999Vx'''''''''''''''
45602	44829	{
45603		- state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
	44830	+ state.addr = 18446744073709548980LLU; // 99999999Vy'''''''''''''''
45604	44831	break;
45605	44832	}
45606		- case 18446744073709548933LLU: // 99999999VE'''''''''''''''
	44833	+ case 18446744073709548980LLU: // 99999999Vy'''''''''''''''
45607	44834	{
45608	44835	fprintf(stderr, "%s", ": ");
45609	44836	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45612,7 +44839,7 @@
45612	44839	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45613	44840	}
45614	44841	// ACCUMULATE ARGUMENTS - END
45615		- uint64_t return_to = 18446744073709548930LLU;
	44842	+ uint64_t return_to = 18446744073709548977LLU;
45616	44843	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45617	44844	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45618	44845	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45621,12 +44848,12 @@
45621	44848	state.addr = 819847183518878432LLU; // reporttype
45622	44849	break;
45623	44850	}
45624		- case 18446744073709548930LLU: // 99999999VB'''''''''''''''
	44851	+ case 18446744073709548977LLU: // 99999999Vv'''''''''''''''
45625	44852	{
45626		- state.addr = 18446744073709548931LLU; // 99999999VC'''''''''''''''
	44853	+ state.addr = 18446744073709548978LLU; // 99999999Vw'''''''''''''''
45627	44854	break;
45628	44855	}
45629		- case 18446744073709548931LLU: // 99999999VC'''''''''''''''
	44856	+ case 18446744073709548978LLU: // 99999999Vw'''''''''''''''
45630	44857	{
45631	44858	fprintf(stderr, "%s", " != ");
45632	44859	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45635,7 +44862,7 @@
45635	44862	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45636	44863	}
45637	44864	// ACCUMULATE ARGUMENTS - END
45638		- uint64_t return_to = 18446744073709548928LLU;
	44865	+ uint64_t return_to = 18446744073709548975LLU;
45639	44866	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45640	44867	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45641	44868	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45644,21 +44871,21 @@
45644	44871	state.addr = 819847183518878432LLU; // reporttype
45645	44872	break;
45646	44873	}
45647		- case 18446744073709548928LLU: // 99999999V_'''''''''''''''
	44874	+ case 18446744073709548975LLU: // 99999999Vt'''''''''''''''
45648	44875	{
45649		- state.addr = 18446744073709548929LLU; // 99999999VA'''''''''''''''
	44876	+ state.addr = 18446744073709548976LLU; // 99999999Vu'''''''''''''''
45650	44877	break;
45651	44878	}
45652		- case 18446744073709548929LLU: // 99999999VA'''''''''''''''
	44879	+ case 18446744073709548976LLU: // 99999999Vu'''''''''''''''
45653	44880	{
45654	44881	{
45655	44882	fprintf(stderr, "%s\n", "");
45656	44883	exit(-1);
45657	44884	}
45658		- state.addr = 18446744073709548936LLU; // 99999999VH'''''''''''''''
	44885	+ state.addr = 18446744073709548983LLU; // 99999999V1'''''''''''''''
45659	44886	break;
45660	44887	}
45661		- case 18446744073709548936LLU: // 99999999VH'''''''''''''''
	44888	+ case 18446744073709548983LLU: // 99999999V1'''''''''''''''
45662	44889	{
45663	44890	// variable u64 subtypeb__ goes out of scope
45664	44891	// emitted destructur for type u64

		@@ -45675,10 +44902,10 @@
45675	44902	// variable u64 result____ goes out of scope
45676	44903	// emitted destructur for type u64
45677	44904	(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'''''''''''''''
45679	44906	break;
45680	44907	}
45681		- case 18446744073709548956LLU: // 99999999Va'''''''''''''''
	44908	+ case 18446744073709549003LLU: // 99999999WK'''''''''''''''
45682	44909	{
45683	44910	// ACCUMULATE ARGUMENTS - BEGIN
45684	44911	{

		@@ -45698,7 +44925,7 @@
45698	44925	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45699	44926	}
45700	44927	// ACCUMULATE ARGUMENTS - END
45701		- uint64_t return_to = 18446744073709548926LLU;
	44928	+ uint64_t return_to = 18446744073709548973LLU;
45702	44929	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45703	44930	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45704	44931	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45707,27 +44934,27 @@
45707	44934	state.addr = 660220410725010287LLU; // initassert
45708	44935	break;
45709	44936	}
45710		- case 18446744073709548926LLU: // 99999999U8'''''''''''''''
	44937	+ case 18446744073709548973LLU: // 99999999Vr'''''''''''''''
45711	44938	{
45712		- state.addr = 18446744073709548927LLU; // 99999999U9'''''''''''''''
	44939	+ state.addr = 18446744073709548974LLU; // 99999999Vs'''''''''''''''
45713	44940	break;
45714	44941	}
45715		- case 18446744073709548927LLU: // 99999999U9'''''''''''''''
	44942	+ case 18446744073709548974LLU: // 99999999Vs'''''''''''''''
45716	44943	{
45717		- state.addr = /initialize/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548925LLU : 18446744073709548924LLU;
	44944	+ state.addr = /initialize/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548972LLU : 18446744073709548971LLU;
45718	44945	break;
45719	44946	}
45720		- case 18446744073709548925LLU: // 99999999U7'''''''''''''''
	44947	+ case 18446744073709548972LLU: // 99999999Vq'''''''''''''''
45721	44948	{
45722		- state.addr = /parameter_/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548923LLU : 18446744073709548922LLU;
	44949	+ state.addr = /parameter_/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548970LLU : 18446744073709548969LLU;
45723	44950	break;
45724	44951	}
45725		- case 18446744073709548923LLU: // 99999999U5'''''''''''''''
	44952	+ case 18446744073709548970LLU: // 99999999Vo'''''''''''''''
45726	44953	{
45727		- state.addr = /consume___/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548921LLU : 18446744073709548920LLU;
	44954	+ state.addr = /consume___/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548968LLU : 18446744073709548967LLU;
45728	44955	break;
45729	44956	}
45730		- case 18446744073709548921LLU: // 99999999U3'''''''''''''''
	44957	+ case 18446744073709548968LLU: // 99999999Vm'''''''''''''''
45731	44958	{
45732	44959	// ACCUMULATE ARGUMENTS - BEGIN
45733	44960	{

		@@ -45747,7 +44974,7 @@
45747	44974	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45748	44975	}
45749	44976	// ACCUMULATE ARGUMENTS - END
45750		- uint64_t return_to = 18446744073709548918LLU;
	44977	+ uint64_t return_to = 18446744073709548965LLU;
45751	44978	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45752	44979	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45753	44980	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45756,19 +44983,19 @@
45756	44983	state.addr = 732615645798520865LLU; // movevarref
45757	44984	break;
45758	44985	}
45759		- case 18446744073709548918LLU: // 99999999U0'''''''''''''''
	44986	+ case 18446744073709548965LLU: // 99999999Vj'''''''''''''''
45760	44987	{
45761		- state.addr = 18446744073709548919LLU; // 99999999U1'''''''''''''''
	44988	+ state.addr = 18446744073709548966LLU; // 99999999Vk'''''''''''''''
45762	44989	break;
45763	44990	}
45764		- case 18446744073709548919LLU: // 99999999U1'''''''''''''''
	44991	+ case 18446744073709548966LLU: // 99999999Vk'''''''''''''''
45765	44992	{
45766	44993	heap.availilable_size_for_dynamic_objects += 0LLU;
45767	44994	heap.availilable_size_for_dynamic_objects += 0LLU;
45768		- state.addr = 18446744073709548917LLU; // 99999999Uz'''''''''''''''
	44995	+ state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
45769	44996	break;
45770	44997	}
45771		- case 18446744073709548920LLU: // 99999999U2'''''''''''''''
	44998	+ case 18446744073709548967LLU: // 99999999Vl'''''''''''''''
45772	44999	{
45773	45000	// ACCUMULATE ARGUMENTS - BEGIN
45774	45001	{

		@@ -45776,7 +45003,7 @@
45776	45003	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45777	45004	}
45778	45005	// ACCUMULATE ARGUMENTS - END
45779		- uint64_t return_to = 18446744073709548915LLU;
	45006	+ uint64_t return_to = 18446744073709548962LLU;
45780	45007	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45781	45008	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45782	45009	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45785,12 +45012,12 @@
45785	45012	state.addr = 819847183515949359LLU; // reportinit
45786	45013	break;
45787	45014	}
45788		- case 18446744073709548915LLU: // 99999999Ux'''''''''''''''
	45015	+ case 18446744073709548962LLU: // 99999999Vg'''''''''''''''
45789	45016	{
45790		- state.addr = 18446744073709548916LLU; // 99999999Uy'''''''''''''''
	45017	+ state.addr = 18446744073709548963LLU; // 99999999Vh'''''''''''''''
45791	45018	break;
45792	45019	}
45793		- case 18446744073709548916LLU: // 99999999Uy'''''''''''''''
	45020	+ case 18446744073709548963LLU: // 99999999Vh'''''''''''''''
45794	45021	{
45795	45022	fprintf(stderr, "%s", "can't move parameter ");
45796	45023	printid(stderr, /argid_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 5LLU)));

		@@ -45798,17 +45025,17 @@
45798	45025	fprintf(stderr, "%s\n", "");
45799	45026	exit(-1);
45800	45027	}
45801		- state.addr = 18446744073709548917LLU; // 99999999Uz'''''''''''''''
	45028	+ state.addr = 18446744073709548964LLU; // 99999999Vi'''''''''''''''
45802	45029	break;
45803	45030	}
45804		- case 18446744073709548917LLU: // 99999999Uz'''''''''''''''
	45031	+ case 18446744073709548964LLU: // 99999999Vi'''''''''''''''
45805	45032	{
45806	45033	heap.availilable_size_for_dynamic_objects += 0LLU;
45807	45034	heap.availilable_size_for_dynamic_objects += 0LLU;
45808		- state.addr = 18446744073709548914LLU; // 99999999Uw'''''''''''''''
	45035	+ state.addr = 18446744073709548961LLU; // 99999999Vf'''''''''''''''
45809	45036	break;
45810	45037	}
45811		- case 18446744073709548922LLU: // 99999999U4'''''''''''''''
	45038	+ case 18446744073709548969LLU: // 99999999Vn'''''''''''''''
45812	45039	{
45813	45040	// ACCUMULATE ARGUMENTS - BEGIN
45814	45041	{

		@@ -45828,7 +45055,7 @@
45828	45055	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45829	45056	}
45830	45057	// ACCUMULATE ARGUMENTS - END
45831		- uint64_t return_to = 18446744073709548912LLU;
	45058	+ uint64_t return_to = 18446744073709548959LLU;
45832	45059	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45833	45060	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45834	45061	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45837,24 +45064,24 @@
45837	45064	state.addr = 732615645798520865LLU; // movevarref
45838	45065	break;
45839	45066	}
45840		- case 18446744073709548912LLU: // 99999999Uu'''''''''''''''
	45067	+ case 18446744073709548959LLU: // 99999999Vd'''''''''''''''
45841	45068	{
45842		- state.addr = 18446744073709548913LLU; // 99999999Uv'''''''''''''''
	45069	+ state.addr = 18446744073709548960LLU; // 99999999Ve'''''''''''''''
45843	45070	break;
45844	45071	}
45845		- case 18446744073709548913LLU: // 99999999Uv'''''''''''''''
	45072	+ case 18446744073709548960LLU: // 99999999Ve'''''''''''''''
45846	45073	{
45847		- state.addr = 18446744073709548914LLU; // 99999999Uw'''''''''''''''
	45074	+ state.addr = 18446744073709548961LLU; // 99999999Vf'''''''''''''''
45848	45075	break;
45849	45076	}
45850		- case 18446744073709548914LLU: // 99999999Uw'''''''''''''''
	45077	+ case 18446744073709548961LLU: // 99999999Vf'''''''''''''''
45851	45078	{
45852	45079	heap.availilable_size_for_dynamic_objects += 0LLU;
45853	45080	heap.availilable_size_for_dynamic_objects += 0LLU;
45854		- state.addr = 18446744073709548911LLU; // 99999999Ut'''''''''''''''
	45081	+ state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
45855	45082	break;
45856	45083	}
45857		- case 18446744073709548924LLU: // 99999999U6'''''''''''''''
	45084	+ case 18446744073709548971LLU: // 99999999Vp'''''''''''''''
45858	45085	{
45859	45086	// ACCUMULATE ARGUMENTS - BEGIN
45860	45087	{

		@@ -45862,7 +45089,7 @@
45862	45089	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45863	45090	}
45864	45091	// ACCUMULATE ARGUMENTS - END
45865		- uint64_t return_to = 18446744073709548909LLU;
	45092	+ uint64_t return_to = 18446744073709548956LLU;
45866	45093	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45867	45094	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45868	45095	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45871,12 +45098,12 @@
45871	45098	state.addr = 819847183515949359LLU; // reportinit
45872	45099	break;
45873	45100	}
45874		- case 18446744073709548909LLU: // 99999999Ur'''''''''''''''
	45101	+ case 18446744073709548956LLU: // 99999999Va'''''''''''''''
45875	45102	{
45876		- state.addr = 18446744073709548910LLU; // 99999999Us'''''''''''''''
	45103	+ state.addr = 18446744073709548957LLU; // 99999999Vb'''''''''''''''
45877	45104	break;
45878	45105	}
45879		- case 18446744073709548910LLU: // 99999999Us'''''''''''''''
	45106	+ case 18446744073709548957LLU: // 99999999Vb'''''''''''''''
45880	45107	{
45881	45108	fprintf(stderr, "%s", "[call to ");
45882	45109	printid(stderr, /constrid__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 1LLU)));

		@@ -45886,10 +45113,10 @@
45886	45113	fprintf(stderr, "%s\n", "");
45887	45114	exit(-1);
45888	45115	}
45889		- state.addr = 18446744073709548911LLU; // 99999999Ut'''''''''''''''
	45116	+ state.addr = 18446744073709548958LLU; // 99999999Vc'''''''''''''''
45890	45117	break;
45891	45118	}
45892		- case 18446744073709548911LLU: // 99999999Ut'''''''''''''''
	45119	+ case 18446744073709548958LLU: // 99999999Vc'''''''''''''''
45893	45120	{
45894	45121	// variable u64 consume___ goes out of scope
45895	45122	// emitted destructur for type u64

		@@ -45911,7 +45138,7 @@
45911	45138	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45912	45139	}
45913	45140	// ACCUMULATE ARGUMENTS - END
45914		- uint64_t return_to = 18446744073709548908LLU;
	45141	+ uint64_t return_to = 18446744073709548955LLU;
45915	45142	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45916	45143	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45917	45144	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45920,7 +45147,7 @@
45920	45147	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
45921	45148	break;
45922	45149	}
45923		- case 18446744073709548908LLU: // 99999999Uq'''''''''''''''
	45150	+ case 18446744073709548955LLU: // 99999999V$'''''''''''''''
45924	45151	{
45925	45152	(void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typearg___ at 15
45926	45153	// variable u64 indirect__ goes out of scope

		@@ -45964,10 +45191,10 @@
45964	45191	}
45965	45192	case 54378275173643538LLU: // CALLCONSTR
45966	45193	{
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;
45968	45195	break;
45969	45196	}
45970		- case 18446744073709548907LLU: // 99999999Up'''''''''''''''
	45197	+ case 18446744073709548954LLU: // 99999999VZ'''''''''''''''
45971	45198	{
45972	45199	{
45973	45200	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 @@
46013	45240	};
46014	45241	*LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = arg;
46015	45242	}
46016		- state.addr = 18446744073709548905LLU; // 99999999Un'''''''''''''''
	45243	+ state.addr = 18446744073709548952LLU; // 99999999VX'''''''''''''''
46017	45244	break;
46018	45245	}
46019		- case 18446744073709548905LLU: // 99999999Un'''''''''''''''
	45246	+ case 18446744073709548952LLU: // 99999999VX'''''''''''''''
46020	45247	{
46021	45248	// ACCUMULATE ARGUMENTS - BEGIN
46022	45249	{

		@@ -46036,7 +45263,7 @@
46036	45263	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46037	45264	}
46038	45265	// ACCUMULATE ARGUMENTS - END
46039		- uint64_t return_to = 18446744073709548903LLU;
	45266	+ uint64_t return_to = 18446744073709548950LLU;
46040	45267	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46041	45268	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46042	45269	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46045,12 +45272,12 @@
46045	45272	state.addr = 621706743143069729LLU; // gettypedef
46046	45273	break;
46047	45274	}
46048		- case 18446744073709548903LLU: // 99999999Ul'''''''''''''''
	45275	+ case 18446744073709548950LLU: // 99999999VV'''''''''''''''
46049	45276	{
46050		- state.addr = 18446744073709548904LLU; // 99999999Um'''''''''''''''
	45277	+ state.addr = 18446744073709548951LLU; // 99999999VW'''''''''''''''
46051	45278	break;
46052	45279	}
46053		- case 18446744073709548904LLU: // 99999999Um'''''''''''''''
	45280	+ case 18446744073709548951LLU: // 99999999VW'''''''''''''''
46054	45281	{
46055	45282	{
46056	45283	uint64_t arg = tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU), 1LLU);

		@@ -46060,10 +45287,10 @@
46060	45287	uint64_t arg = tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 18LLU, 16LLU), 2LLU);
46061	45288	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
46062	45289	}
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;
46064	45291	break;
46065	45292	}
46066		- case 18446744073709548901LLU: // 99999999Uj'''''''''''''''
	45293	+ case 18446744073709548948LLU: // 99999999VT'''''''''''''''
46067	45294	{
46068	45295	{
46069	45296	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 @@
46087	45314	uint64_t arg = 0;
46088	45315	LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/address of current closure/, &arg);
46089	45316	}
46090		- state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
	45317	+ state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
46091	45318	break;
46092	45319	}
46093		- case 18446744073709548899LLU: // 99999999Uh'''''''''''''''
	45320	+ case 18446744073709548946LLU: // 99999999VR'''''''''''''''
46094	45321	{
46095	45322	if(!*LOCAL_ACCESS(heap.data, 24LLU, 22LLU))
46096	45323	{

		@@ -46097,16 +45324,16 @@
46097	45324	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 24
46098	45325	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
46099	45326	{
46100		- state.addr = 18446744073709548898LLU; // 99999999Ug'''''''''''''''
	45327	+ state.addr = 18446744073709548945LLU; // 99999999VQ'''''''''''''''
46101	45328	break;
46102	45329	}
46103	45330	}
46104	45331	/direct/LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = (LOCAL_ACCESS(heap.data, 24LLU, 22LLU) << 1) + 1LLU;
46105	45332	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;
46107	45334	break;
46108	45335	}
46109		- case 18446744073709548897LLU: // 99999999Uf'''''''''''''''
	45336	+ case 18446744073709548944LLU: // 99999999VP'''''''''''''''
46110	45337	{
46111	45338	{
46112	45339	uint64_t arg = 0LLU;

		@@ -46113,10 +45340,10 @@
46113	45340	LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
46114	45341	}
46115	45342	/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;
46117	45344	break;
46118	45345	}
46119		- case 18446744073709548895LLU: // 99999999Ud'''''''''''''''
	45346	+ case 18446744073709548942LLU: // 99999999VN'''''''''''''''
46120	45347	{
46121	45348	*LOCAL_ACCESS(heap.data, 25LLU, 21LLU) = 0LLU;
46122	45349

		@@ -46130,7 +45357,7 @@
46130	45357	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46131	45358	}
46132	45359	// ACCUMULATE ARGUMENTS - END
46133		- uint64_t return_to = 18446744073709548892LLU;
	45360	+ uint64_t return_to = 18446744073709548939LLU;
46134	45361	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46135	45362	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46136	45363	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46139,46 +45366,46 @@
46139	45366	state.addr = 587581813005601646LLU; // elems2pars
46140	45367	break;
46141	45368	}
46142		- case 18446744073709548892LLU: // 99999999Ua'''''''''''''''
	45369	+ case 18446744073709548939LLU: // 99999999VK'''''''''''''''
46143	45370	{
46144		- state.addr = 18446744073709548893LLU; // 99999999Ub'''''''''''''''
	45371	+ state.addr = 18446744073709548940LLU; // 99999999VL'''''''''''''''
46145	45372	break;
46146	45373	}
46147		- case 18446744073709548893LLU: // 99999999Ub'''''''''''''''
	45374	+ case 18446744073709548940LLU: // 99999999VL'''''''''''''''
46148	45375	{
46149	45376	list_reverse(heap.data, &/elems_____/*LOCAL_ACCESS(heap.data, 25LLU, 13LLU));
46150	45377	heap.availilable_size_for_dynamic_objects += 0LLU;
46151	45378	heap.availilable_size_for_dynamic_objects += 0LLU;
46152		- state.addr = 18446744073709548891LLU; // 99999999U$'''''''''''''''
	45379	+ state.addr = 18446744073709548938LLU; // 99999999VJ'''''''''''''''
46153	45380	break;
46154	45381	}
46155		- case 18446744073709548894LLU: // 99999999Uc'''''''''''''''
	45382	+ case 18446744073709548941LLU: // 99999999VM'''''''''''''''
46156	45383	{
46157	45384	++/variantidx/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU);
46158		- state.addr = 18446744073709548891LLU; // 99999999U$'''''''''''''''
	45385	+ state.addr = 18446744073709548938LLU; // 99999999VJ'''''''''''''''
46159	45386	break;
46160	45387	}
46161		- case 18446744073709548891LLU: // 99999999U$'''''''''''''''
	45388	+ case 18446744073709548938LLU: // 99999999VJ'''''''''''''''
46162	45389	{
46163	45390	// variable u64 foundmatch goes out of scope
46164	45391	// emitted destructur for type u64
46165	45392	(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'''''''''''''''
46167	45394	break;
46168	45395	}
46169		- case 18446744073709548896LLU: // 99999999Ue'''''''''''''''
	45396	+ case 18446744073709548943LLU: // 99999999VO'''''''''''''''
46170	45397	{
46171	45398	// parameter-reference variant___ constr____ goes out of scope
46172	45399	// parameter-reference list<variant___> constrs___ goes out of scope
46173		- state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
	45400	+ state.addr = 18446744073709548946LLU; // 99999999VR'''''''''''''''
46174	45401	break;
46175	45402	}
46176		- case 18446744073709548898LLU: // 99999999Ug'''''''''''''''
	45403	+ case 18446744073709548945LLU: // 99999999VQ'''''''''''''''
46177	45404	{
46178		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548890LLU : 18446744073709548889LLU;
	45405	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548937LLU : 18446744073709548936LLU;
46179	45406	break;
46180	45407	}
46181		- case 18446744073709548890LLU: // 99999999UZ'''''''''''''''
	45408	+ case 18446744073709548937LLU: // 99999999VI'''''''''''''''
46182	45409	{
46183	45410	// ACCUMULATE ARGUMENTS - BEGIN
46184	45411	{

		@@ -46186,7 +45413,7 @@
46186	45413	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46187	45414	}
46188	45415	// ACCUMULATE ARGUMENTS - END
46189		- uint64_t return_to = 18446744073709548887LLU;
	45416	+ uint64_t return_to = 18446744073709548934LLU;
46190	45417	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46191	45418	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46192	45419	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46195,12 +45422,12 @@
46195	45422	state.addr = 819847183515949359LLU; // reportinit
46196	45423	break;
46197	45424	}
46198		- case 18446744073709548887LLU: // 99999999UW'''''''''''''''
	45425	+ case 18446744073709548934LLU: // 99999999VF'''''''''''''''
46199	45426	{
46200		- state.addr = 18446744073709548888LLU; // 99999999UX'''''''''''''''
	45427	+ state.addr = 18446744073709548935LLU; // 99999999VG'''''''''''''''
46201	45428	break;
46202	45429	}
46203		- case 18446744073709548888LLU: // 99999999UX'''''''''''''''
	45430	+ case 18446744073709548935LLU: // 99999999VG'''''''''''''''
46204	45431	{
46205	45432	fprintf(stderr, "%s", "union ");
46206	45433	printid(stderr, /maintype__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 12LLU)));

		@@ -46210,10 +45437,10 @@
46210	45437	fprintf(stderr, "%s\n", "");
46211	45438	exit(-1);
46212	45439	}
46213		- state.addr = 18446744073709548889LLU; // 99999999UY'''''''''''''''
	45440	+ state.addr = 18446744073709548936LLU; // 99999999VH'''''''''''''''
46214	45441	break;
46215	45442	}
46216		- case 18446744073709548889LLU: // 99999999UY'''''''''''''''
	45443	+ case 18446744073709548936LLU: // 99999999VH'''''''''''''''
46217	45444	{
46218	45445	{
46219	45446	uint64_t arg = 0LLU;

		@@ -46227,10 +45454,10 @@
46227	45454	uint64_t arg = 0;
46228	45455	LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
46229	45456	}
46230		- state.addr = 18446744073709548886LLU; // 99999999UV'''''''''''''''
	45457	+ state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
46231	45458	break;
46232	45459	}
46233		- case 18446744073709548886LLU: // 99999999UV'''''''''''''''
	45460	+ case 18446744073709548933LLU: // 99999999VE'''''''''''''''
46234	45461	{
46235	45462	if(!*LOCAL_ACCESS(heap.data, 25LLU, 23LLU))
46236	45463	{

		@@ -46237,16 +45464,16 @@
46237	45464	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 25
46238	45465	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 24
46239	45466	{
46240		- state.addr = 18446744073709548885LLU; // 99999999UU'''''''''''''''
	45467	+ state.addr = 18446744073709548932LLU; // 99999999VD'''''''''''''''
46241	45468	break;
46242	45469	}
46243	45470	}
46244	45471	/direct/LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = (LOCAL_ACCESS(heap.data, 25LLU, 23LLU) << 1) + 1LLU;
46245	45472	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;
46247	45474	break;
46248	45475	}
46249		- case 18446744073709548884LLU: // 99999999UT'''''''''''''''
	45476	+ case 18446744073709548931LLU: // 99999999VC'''''''''''''''
46250	45477	{
46251	45478	// ACCUMULATE ARGUMENTS - BEGIN
46252	45479	{

		@@ -46254,7 +45481,7 @@
46254	45481	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46255	45482	}
46256	45483	// ACCUMULATE ARGUMENTS - END
46257		- uint64_t return_to = 18446744073709548881LLU;
	45484	+ uint64_t return_to = 18446744073709548928LLU;
46258	45485	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46259	45486	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46260	45487	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46263,18 +45490,18 @@
46263	45490	state.addr = 839519719621918720LLU; // skipws____
46264	45491	break;
46265	45492	}
46266		- case 18446744073709548881LLU: // 99999999UQ'''''''''''''''
	45493	+ case 18446744073709548928LLU: // 99999999V_'''''''''''''''
46267	45494	{
46268		- state.addr = 18446744073709548882LLU; // 99999999UR'''''''''''''''
	45495	+ state.addr = 18446744073709548929LLU; // 99999999VA'''''''''''''''
46269	45496	break;
46270	45497	}
46271		- case 18446744073709548882LLU: // 99999999UR'''''''''''''''
	45498	+ case 18446744073709548929LLU: // 99999999VA'''''''''''''''
46272	45499	{
46273	45500	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 5LLU)));
46274		- state.addr = 18446744073709548883LLU; // 99999999US'''''''''''''''
	45501	+ state.addr = 18446744073709548930LLU; // 99999999VB'''''''''''''''
46275	45502	break;
46276	45503	}
46277		- case 18446744073709548883LLU: // 99999999US'''''''''''''''
	45504	+ case 18446744073709548930LLU: // 99999999VB'''''''''''''''
46278	45505	{
46279	45506	{
46280	45507	uint64_t arg = 0LLU;

		@@ -46290,7 +45517,7 @@
46290	45517	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46291	45518	}
46292	45519	// ACCUMULATE ARGUMENTS - END
46293		- uint64_t return_to = 18446744073709548878LLU;
	45520	+ uint64_t return_to = 18446744073709548925LLU;
46294	45521	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46295	45522	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46296	45523	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46299,12 +45526,12 @@
46299	45526	state.addr = 839519719621918720LLU; // skipws____
46300	45527	break;
46301	45528	}
46302		- case 18446744073709548878LLU: // 99999999UN'''''''''''''''
	45529	+ case 18446744073709548925LLU: // 99999999U7'''''''''''''''
46303	45530	{
46304		- state.addr = 18446744073709548879LLU; // 99999999UO'''''''''''''''
	45531	+ state.addr = 18446744073709548926LLU; // 99999999U8'''''''''''''''
46305	45532	break;
46306	45533	}
46307		- case 18446744073709548879LLU: // 99999999UO'''''''''''''''
	45534	+ case 18446744073709548926LLU: // 99999999U8'''''''''''''''
46308	45535	{
46309	45536	// ACCUMULATE ARGUMENTS - BEGIN
46310	45537	{

		@@ -46316,7 +45543,7 @@
46316	45543	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46317	45544	}
46318	45545	// ACCUMULATE ARGUMENTS - END
46319		- uint64_t return_to = 18446744073709548876LLU;
	45546	+ uint64_t return_to = 18446744073709548923LLU;
46320	45547	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46321	45548	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46322	45549	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46325,17 +45552,17 @@
46325	45552	state.addr = 661592067397386240LLU; // isalpha___
46326	45553	break;
46327	45554	}
46328		- case 18446744073709548876LLU: // 99999999UL'''''''''''''''
	45555	+ case 18446744073709548923LLU: // 99999999U5'''''''''''''''
46329	45556	{
46330		- state.addr = 18446744073709548877LLU; // 99999999UM'''''''''''''''
	45557	+ state.addr = 18446744073709548924LLU; // 99999999U6'''''''''''''''
46331	45558	break;
46332	45559	}
46333		- case 18446744073709548877LLU: // 99999999UM'''''''''''''''
	45560	+ case 18446744073709548924LLU: // 99999999U6'''''''''''''''
46334	45561	{
46335		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709548875LLU : 18446744073709548874LLU;
	45562	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) ? 18446744073709548922LLU : 18446744073709548921LLU;
46336	45563	break;
46337	45564	}
46338		- case 18446744073709548875LLU: // 99999999UK'''''''''''''''
	45565	+ case 18446744073709548922LLU: // 99999999U4'''''''''''''''
46339	45566	{
46340	45567	{
46341	45568	uint64_t arg = 0LLU;

		@@ -46347,7 +45574,7 @@
46347	45574	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46348	45575	}
46349	45576	// ACCUMULATE ARGUMENTS - END
46350		- uint64_t return_to = 18446744073709548872LLU;
	45577	+ uint64_t return_to = 18446744073709548919LLU;
46351	45578	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46352	45579	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46353	45580	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46356,12 +45583,12 @@
46356	45583	state.addr = 839519719621918720LLU; // skipws____
46357	45584	break;
46358	45585	}
46359		- case 18446744073709548872LLU: // 99999999UH'''''''''''''''
	45586	+ case 18446744073709548919LLU: // 99999999U1'''''''''''''''
46360	45587	{
46361		- state.addr = 18446744073709548873LLU; // 99999999UI'''''''''''''''
	45588	+ state.addr = 18446744073709548920LLU; // 99999999U2'''''''''''''''
46362	45589	break;
46363	45590	}
46364		- case 18446744073709548873LLU: // 99999999UI'''''''''''''''
	45591	+ case 18446744073709548920LLU: // 99999999U2'''''''''''''''
46365	45592	{
46366	45593	/argid_____/LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 5LLU)));
46367	45594	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46370,7 +45597,7 @@
46370	45597	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46371	45598	}
46372	45599	// ACCUMULATE ARGUMENTS - END
46373		- uint64_t return_to = 18446744073709548870LLU;
	45600	+ uint64_t return_to = 18446744073709548917LLU;
46374	45601	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46375	45602	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46376	45603	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46379,12 +45606,12 @@
46379	45606	state.addr = 839519719621918720LLU; // skipws____
46380	45607	break;
46381	45608	}
46382		- case 18446744073709548870LLU: // 99999999UF'''''''''''''''
	45609	+ case 18446744073709548917LLU: // 99999999Uz'''''''''''''''
46383	45610	{
46384		- state.addr = 18446744073709548871LLU; // 99999999UG'''''''''''''''
	45611	+ state.addr = 18446744073709548918LLU; // 99999999U0'''''''''''''''
46385	45612	break;
46386	45613	}
46387		- case 18446744073709548871LLU: // 99999999UG'''''''''''''''
	45614	+ case 18446744073709548918LLU: // 99999999U0'''''''''''''''
46388	45615	{
46389	45616	*LOCAL_ACCESS(heap.data, 28LLU, 25LLU) = 40LLU;
46390	45617

		@@ -46406,7 +45633,7 @@
46406	45633	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46407	45634	}
46408	45635	// ACCUMULATE ARGUMENTS - END
46409		- uint64_t return_to = 18446744073709548868LLU;
	45636	+ uint64_t return_to = 18446744073709548915LLU;
46410	45637	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
46411	45638	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46412	45639	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46415,22 +45642,22 @@
46415	45642	state.addr = 728666047794575267LLU; // matchoptch
46416	45643	break;
46417	45644	}
46418		- case 18446744073709548868LLU: // 99999999UD'''''''''''''''
	45645	+ case 18446744073709548915LLU: // 99999999Ux'''''''''''''''
46419	45646	{
46420		- state.addr = 18446744073709548869LLU; // 99999999UE'''''''''''''''
	45647	+ state.addr = 18446744073709548916LLU; // 99999999Uy'''''''''''''''
46421	45648	break;
46422	45649	}
46423		- case 18446744073709548869LLU: // 99999999UE'''''''''''''''
	45650	+ case 18446744073709548916LLU: // 99999999Uy'''''''''''''''
46424	45651	{
46425		- state.addr = /called____/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU) ? 18446744073709548867LLU : 18446744073709548866LLU;
	45652	+ state.addr = /called____/*LOCAL_ACCESS(heap.data, 29LLU, 28LLU) ? 18446744073709548914LLU : 18446744073709548913LLU;
46426	45653	break;
46427	45654	}
46428		- case 18446744073709548867LLU: // 99999999UC'''''''''''''''
	45655	+ case 18446744073709548914LLU: // 99999999Uw'''''''''''''''
46429	45656	{
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;
46431	45658	break;
46432	45659	}
46433		- case 18446744073709548865LLU: // 99999999UA'''''''''''''''
	45660	+ case 18446744073709548912LLU: // 99999999Uu'''''''''''''''
46434	45661	{
46435	45662
46436	45663	heap.availilable_size_for_dynamic_objects -= (31LLU + 8LLU);

		@@ -46442,7 +45669,7 @@
46442	45669	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46443	45670	}
46444	45671	// ACCUMULATE ARGUMENTS - END
46445		- uint64_t return_to = 18446744073709548862LLU;
	45672	+ uint64_t return_to = 18446744073709548909LLU;
46446	45673	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46447	45674	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46448	45675	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46451,12 +45678,12 @@
46451	45678	state.addr = 819790006513303552LLU; // recopen___
46452	45679	break;
46453	45680	}
46454		- case 18446744073709548862LLU: // 99999999T8'''''''''''''''
	45681	+ case 18446744073709548909LLU: // 99999999Ur'''''''''''''''
46455	45682	{
46456		- state.addr = 18446744073709548863LLU; // 99999999T9'''''''''''''''
	45683	+ state.addr = 18446744073709548910LLU; // 99999999Us'''''''''''''''
46457	45684	break;
46458	45685	}
46459		- case 18446744073709548863LLU: // 99999999T9'''''''''''''''
	45686	+ case 18446744073709548910LLU: // 99999999Us'''''''''''''''
46460	45687	{
46461	45688	fprintf(stdout, "%s", "0LLU");
46462	45689	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46509,7 +45736,7 @@
46509	45736	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46510	45737	}
46511	45738	// ACCUMULATE ARGUMENTS - END
46512		- uint64_t return_to = 18446744073709548860LLU;
	45739	+ uint64_t return_to = 18446744073709548907LLU;
46513	45740	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
46514	45741	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46515	45742	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46518,12 +45745,12 @@
46518	45745	state.addr = 54378275173643538LLU; // CALLCONSTR
46519	45746	break;
46520	45747	}
46521		- case 18446744073709548860LLU: // 99999999T6'''''''''''''''
	45748	+ case 18446744073709548907LLU: // 99999999Up'''''''''''''''
46522	45749	{
46523		- state.addr = 18446744073709548861LLU; // 99999999T7'''''''''''''''
	45750	+ state.addr = 18446744073709548908LLU; // 99999999Uq'''''''''''''''
46524	45751	break;
46525	45752	}
46526		- case 18446744073709548861LLU: // 99999999T7'''''''''''''''
	45753	+ case 18446744073709548908LLU: // 99999999Uq'''''''''''''''
46527	45754	{
46528	45755	// ACCUMULATE ARGUMENTS - BEGIN
46529	45756	{

		@@ -46535,7 +45762,7 @@
46535	45762	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46536	45763	}
46537	45764	// ACCUMULATE ARGUMENTS - END
46538		- uint64_t return_to = 18446744073709548858LLU;
	45765	+ uint64_t return_to = 18446744073709548905LLU;
46539	45766	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46540	45767	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46541	45768	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46544,12 +45771,12 @@
46544	45771	state.addr = 819789177753829376LLU; // recclose__
46545	45772	break;
46546	45773	}
46547		- case 18446744073709548858LLU: // 99999999T4'''''''''''''''
	45774	+ case 18446744073709548905LLU: // 99999999Un'''''''''''''''
46548	45775	{
46549		- state.addr = 18446744073709548859LLU; // 99999999T5'''''''''''''''
	45776	+ state.addr = 18446744073709548906LLU; // 99999999Uo'''''''''''''''
46550	45777	break;
46551	45778	}
46552		- case 18446744073709548859LLU: // 99999999T5'''''''''''''''
	45779	+ case 18446744073709548906LLU: // 99999999Uo'''''''''''''''
46553	45780	{
46554	45781	// ACCUMULATE ARGUMENTS - BEGIN
46555	45782	{

		@@ -46557,7 +45784,7 @@
46557	45784	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46558	45785	}
46559	45786	// ACCUMULATE ARGUMENTS - END
46560		- uint64_t return_to = 18446744073709548856LLU;
	45787	+ uint64_t return_to = 18446744073709548903LLU;
46561	45788	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46562	45789	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46563	45790	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46566,20 +45793,20 @@
46566	45793	state.addr = 839519719621918720LLU; // skipws____
46567	45794	break;
46568	45795	}
46569		- case 18446744073709548856LLU: // 99999999T2'''''''''''''''
	45796	+ case 18446744073709548903LLU: // 99999999Ul'''''''''''''''
46570	45797	{
46571		- state.addr = 18446744073709548857LLU; // 99999999T3'''''''''''''''
	45798	+ state.addr = 18446744073709548904LLU; // 99999999Um'''''''''''''''
46572	45799	break;
46573	45800	}
46574		- case 18446744073709548857LLU: // 99999999T3'''''''''''''''
	45801	+ case 18446744073709548904LLU: // 99999999Um'''''''''''''''
46575	45802	{
46576	45803	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 29LLU, 5LLU)));
46577	45804	heap.availilable_size_for_dynamic_objects += 31LLU;
46578	45805	heap.availilable_size_for_dynamic_objects += 8LLU;
46579		- state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
	45806	+ state.addr = 18446744073709548902LLU; // 99999999Uk'''''''''''''''
46580	45807	break;
46581	45808	}
46582		- case 18446744073709548864LLU: // 99999999U_'''''''''''''''
	45809	+ case 18446744073709548911LLU: // 99999999Ut'''''''''''''''
46583	45810	{
46584	45811	// ACCUMULATE ARGUMENTS - BEGIN
46585	45812	{

		@@ -46587,7 +45814,7 @@
46587	45814	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46588	45815	}
46589	45816	// ACCUMULATE ARGUMENTS - END
46590		- uint64_t return_to = 18446744073709548853LLU;
	45817	+ uint64_t return_to = 18446744073709548900LLU;
46591	45818	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46592	45819	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46593	45820	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46596,28 +45823,28 @@
46596	45823	state.addr = 819847183515949359LLU; // reportinit
46597	45824	break;
46598	45825	}
46599		- case 18446744073709548853LLU: // 99999999Tz'''''''''''''''
	45826	+ case 18446744073709548900LLU: // 99999999Ui'''''''''''''''
46600	45827	{
46601		- state.addr = 18446744073709548854LLU; // 99999999T0'''''''''''''''
	45828	+ state.addr = 18446744073709548901LLU; // 99999999Uj'''''''''''''''
46602	45829	break;
46603	45830	}
46604		- case 18446744073709548854LLU: // 99999999T0'''''''''''''''
	45831	+ case 18446744073709548901LLU: // 99999999Uj'''''''''''''''
46605	45832	{
46606	45833	{
46607	45834	fprintf(stderr, "%s\n", "[INTERNAL ERROR, CALLCONSTR] out of memory - recompile compiler with increased heap-size");
46608	45835	exit(-1);
46609	45836	}
46610		- state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
	45837	+ state.addr = 18446744073709548902LLU; // 99999999Uk'''''''''''''''
46611	45838	break;
46612	45839	}
46613		- case 18446744073709548855LLU: // 99999999T1'''''''''''''''
	45840	+ case 18446744073709548902LLU: // 99999999Uk'''''''''''''''
46614	45841	{
46615	45842	heap.availilable_size_for_dynamic_objects += 0LLU;
46616	45843	heap.availilable_size_for_dynamic_objects += 0LLU;
46617		- state.addr = 18446744073709548852LLU; // 99999999Ty'''''''''''''''
	45844	+ state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
46618	45845	break;
46619	45846	}
46620		- case 18446744073709548866LLU: // 99999999UB'''''''''''''''
	45847	+ case 18446744073709548913LLU: // 99999999Uv'''''''''''''''
46621	45848	{
46622	45849	fprintf(stdout, "%s", ";");
46623	45850	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46626,7 +45853,7 @@
46626	45853	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46627	45854	}
46628	45855	// ACCUMULATE ARGUMENTS - END
46629		- uint64_t return_to = 18446744073709548850LLU;
	45856	+ uint64_t return_to = 18446744073709548897LLU;
46630	45857	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46631	45858	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46632	45859	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46635,12 +45862,12 @@
46635	45862	state.addr = 660197403663532032LLU; // indent____
46636	45863	break;
46637	45864	}
46638		- case 18446744073709548850LLU: // 99999999Tw'''''''''''''''
	45865	+ case 18446744073709548897LLU: // 99999999Uf'''''''''''''''
46639	45866	{
46640		- state.addr = 18446744073709548851LLU; // 99999999Tx'''''''''''''''
	45867	+ state.addr = 18446744073709548898LLU; // 99999999Ug'''''''''''''''
46641	45868	break;
46642	45869	}
46643		- case 18446744073709548851LLU: // 99999999Tx'''''''''''''''
	45870	+ case 18446744073709548898LLU: // 99999999Ug'''''''''''''''
46644	45871	{
46645	45872	fprintf(stdout, "%s", " tree_push_move(&heap, ");
46646	45873	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46649,7 +45876,7 @@
46649	45876	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46650	45877	}
46651	45878	// ACCUMULATE ARGUMENTS - END
46652		- uint64_t return_to = 18446744073709548848LLU;
	45879	+ uint64_t return_to = 18446744073709548895LLU;
46653	45880	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46654	45881	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46655	45882	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46658,12 +45885,12 @@
46658	45885	state.addr = 787446708198178816LLU; // printnr___
46659	45886	break;
46660	45887	}
46661		- case 18446744073709548848LLU: // 99999999Tu'''''''''''''''
	45888	+ case 18446744073709548895LLU: // 99999999Ud'''''''''''''''
46662	45889	{
46663		- state.addr = 18446744073709548849LLU; // 99999999Tv'''''''''''''''
	45890	+ state.addr = 18446744073709548896LLU; // 99999999Ue'''''''''''''''
46664	45891	break;
46665	45892	}
46666		- case 18446744073709548849LLU: // 99999999Tv'''''''''''''''
	45893	+ case 18446744073709548896LLU: // 99999999Ue'''''''''''''''
46667	45894	{
46668	45895	fprintf(stdout, "%s", ", &arg");
46669	45896	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46672,7 +45899,7 @@
46672	45899	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46673	45900	}
46674	45901	// ACCUMULATE ARGUMENTS - END
46675		- uint64_t return_to = 18446744073709548846LLU;
	45902	+ uint64_t return_to = 18446744073709548893LLU;
46676	45903	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46677	45904	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46678	45905	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46681,12 +45908,12 @@
46681	45908	state.addr = 787446708200409962LLU; // printnzero
46682	45909	break;
46683	45910	}
46684		- case 18446744073709548846LLU: // 99999999Ts'''''''''''''''
	45911	+ case 18446744073709548893LLU: // 99999999Ub'''''''''''''''
46685	45912	{
46686		- state.addr = 18446744073709548847LLU; // 99999999Tt'''''''''''''''
	45913	+ state.addr = 18446744073709548894LLU; // 99999999Uc'''''''''''''''
46687	45914	break;
46688	45915	}
46689		- case 18446744073709548847LLU: // 99999999Tt'''''''''''''''
	45916	+ case 18446744073709548894LLU: // 99999999Uc'''''''''''''''
46690	45917	{
46691	45918	fprintf(stdout, "%s", ", &");
46692	45919	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46735,7 +45962,7 @@
46735	45962	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46736	45963	}
46737	45964	// ACCUMULATE ARGUMENTS - END
46738		- uint64_t return_to = 18446744073709548844LLU;
	45965	+ uint64_t return_to = 18446744073709548891LLU;
46739	45966	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
46740	45967	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46741	45968	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46744,18 +45971,18 @@
46744	45971	state.addr = 552437436537559168LLU; // constrarg_
46745	45972	break;
46746	45973	}
46747		- case 18446744073709548844LLU: // 99999999Tq'''''''''''''''
	45974	+ case 18446744073709548891LLU: // 99999999U$'''''''''''''''
46748	45975	{
46749		- state.addr = 18446744073709548845LLU; // 99999999Tr'''''''''''''''
	45976	+ state.addr = 18446744073709548892LLU; // 99999999Ua'''''''''''''''
46750	45977	break;
46751	45978	}
46752		- case 18446744073709548845LLU: // 99999999Tr'''''''''''''''
	45979	+ case 18446744073709548892LLU: // 99999999Ua'''''''''''''''
46753	45980	{
46754	45981	fprintf(stdout, "%s", ")");
46755		- state.addr = 18446744073709548852LLU; // 99999999Ty'''''''''''''''
	45982	+ state.addr = 18446744073709548899LLU; // 99999999Uh'''''''''''''''
46756	45983	break;
46757	45984	}
46758		- case 18446744073709548852LLU: // 99999999Ty'''''''''''''''
	45985	+ case 18446744073709548899LLU: // 99999999Uh'''''''''''''''
46759	45986	{
46760	45987	// variable u64 called____ goes out of scope
46761	45988	// emitted destructur for type u64

		@@ -46765,10 +45992,10 @@
46765	45992	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference argid_____ at 28
46766	45993	heap.availilable_size_for_dynamic_objects += 0LLU;
46767	45994	heap.availilable_size_for_dynamic_objects += 0LLU;
46768		- state.addr = 18446744073709548843LLU; // 99999999Tp'''''''''''''''
	45995	+ state.addr = 18446744073709548890LLU; // 99999999UZ'''''''''''''''
46769	45996	break;
46770	45997	}
46771		- case 18446744073709548874LLU: // 99999999UJ'''''''''''''''
	45998	+ case 18446744073709548921LLU: // 99999999U3'''''''''''''''
46772	45999	{
46773	46000	{
46774	46001	uint64_t arg = 0LLU;

		@@ -46782,7 +46009,7 @@
46782	46009	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46783	46010	}
46784	46011	// ACCUMULATE ARGUMENTS - END
46785		- uint64_t return_to = 18446744073709548841LLU;
	46012	+ uint64_t return_to = 18446744073709548888LLU;
46786	46013	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46787	46014	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46788	46015	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46791,12 +46018,12 @@
46791	46018	state.addr = 660197403663532032LLU; // indent____
46792	46019	break;
46793	46020	}
46794		- case 18446744073709548841LLU: // 99999999Tn'''''''''''''''
	46021	+ case 18446744073709548888LLU: // 99999999UX'''''''''''''''
46795	46022	{
46796		- state.addr = 18446744073709548842LLU; // 99999999To'''''''''''''''
	46023	+ state.addr = 18446744073709548889LLU; // 99999999UY'''''''''''''''
46797	46024	break;
46798	46025	}
46799		- case 18446744073709548842LLU: // 99999999To'''''''''''''''
	46026	+ case 18446744073709548889LLU: // 99999999UY'''''''''''''''
46800	46027	{
46801	46028	fprintf(stdout, "%s", " {");
46802	46029	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46805,7 +46032,7 @@
46805	46032	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46806	46033	}
46807	46034	// ACCUMULATE ARGUMENTS - END
46808		- uint64_t return_to = 18446744073709548839LLU;
	46035	+ uint64_t return_to = 18446744073709548886LLU;
46809	46036	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46810	46037	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46811	46038	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46814,12 +46041,12 @@
46814	46041	state.addr = 660197403663532032LLU; // indent____
46815	46042	break;
46816	46043	}
46817		- case 18446744073709548839LLU: // 99999999Tl'''''''''''''''
	46044	+ case 18446744073709548886LLU: // 99999999UV'''''''''''''''
46818	46045	{
46819		- state.addr = 18446744073709548840LLU; // 99999999Tm'''''''''''''''
	46046	+ state.addr = 18446744073709548887LLU; // 99999999UW'''''''''''''''
46820	46047	break;
46821	46048	}
46822		- case 18446744073709548840LLU: // 99999999Tm'''''''''''''''
	46049	+ case 18446744073709548887LLU: // 99999999UW'''''''''''''''
46823	46050	{
46824	46051	fprintf(stdout, "%s", " uint64_t value = ");
46825	46052	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46828,7 +46055,7 @@
46828	46055	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46829	46056	}
46830	46057	// ACCUMULATE ARGUMENTS - END
46831		- uint64_t return_to = 18446744073709548837LLU;
	46058	+ uint64_t return_to = 18446744073709548884LLU;
46832	46059	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46833	46060	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46834	46061	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46837,12 +46064,12 @@
46837	46064	state.addr = 787446708198178816LLU; // printnr___
46838	46065	break;
46839	46066	}
46840		- case 18446744073709548837LLU: // 99999999Tj'''''''''''''''
	46067	+ case 18446744073709548884LLU: // 99999999UT'''''''''''''''
46841	46068	{
46842		- state.addr = 18446744073709548838LLU; // 99999999Tk'''''''''''''''
	46069	+ state.addr = 18446744073709548885LLU; // 99999999UU'''''''''''''''
46843	46070	break;
46844	46071	}
46845		- case 18446744073709548838LLU: // 99999999Tk'''''''''''''''
	46072	+ case 18446744073709548885LLU: // 99999999UU'''''''''''''''
46846	46073	{
46847	46074	fprintf(stdout, "%s", ";");
46848	46075	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46851,7 +46078,7 @@
46851	46078	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46852	46079	}
46853	46080	// ACCUMULATE ARGUMENTS - END
46854		- uint64_t return_to = 18446744073709548835LLU;
	46081	+ uint64_t return_to = 18446744073709548882LLU;
46855	46082	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46856	46083	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46857	46084	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46860,12 +46087,12 @@
46860	46087	state.addr = 660197403663532032LLU; // indent____
46861	46088	break;
46862	46089	}
46863		- case 18446744073709548835LLU: // 99999999Th'''''''''''''''
	46090	+ case 18446744073709548882LLU: // 99999999UR'''''''''''''''
46864	46091	{
46865		- state.addr = 18446744073709548836LLU; // 99999999Ti'''''''''''''''
	46092	+ state.addr = 18446744073709548883LLU; // 99999999US'''''''''''''''
46866	46093	break;
46867	46094	}
46868		- case 18446744073709548836LLU: // 99999999Ti'''''''''''''''
	46095	+ case 18446744073709548883LLU: // 99999999US'''''''''''''''
46869	46096	{
46870	46097	fprintf(stdout, "%s", " tree_push_move(&heap, ");
46871	46098	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46874,7 +46101,7 @@
46874	46101	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46875	46102	}
46876	46103	// ACCUMULATE ARGUMENTS - END
46877		- uint64_t return_to = 18446744073709548833LLU;
	46104	+ uint64_t return_to = 18446744073709548880LLU;
46878	46105	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46879	46106	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46880	46107	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46883,12 +46110,12 @@
46883	46110	state.addr = 787446708198178816LLU; // printnr___
46884	46111	break;
46885	46112	}
46886		- case 18446744073709548833LLU: // 99999999Tf'''''''''''''''
	46113	+ case 18446744073709548880LLU: // 99999999UP'''''''''''''''
46887	46114	{
46888		- state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
	46115	+ state.addr = 18446744073709548881LLU; // 99999999UQ'''''''''''''''
46889	46116	break;
46890	46117	}
46891		- case 18446744073709548834LLU: // 99999999Tg'''''''''''''''
	46118	+ case 18446744073709548881LLU: // 99999999UQ'''''''''''''''
46892	46119	{
46893	46120	fprintf(stdout, "%s", ", &arg");
46894	46121	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46897,7 +46124,7 @@
46897	46124	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46898	46125	}
46899	46126	// ACCUMULATE ARGUMENTS - END
46900		- uint64_t return_to = 18446744073709548831LLU;
	46127	+ uint64_t return_to = 18446744073709548878LLU;
46901	46128	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46902	46129	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46903	46130	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46906,12 +46133,12 @@
46906	46133	state.addr = 787446708200409962LLU; // printnzero
46907	46134	break;
46908	46135	}
46909		- case 18446744073709548831LLU: // 99999999Td'''''''''''''''
	46136	+ case 18446744073709548878LLU: // 99999999UN'''''''''''''''
46910	46137	{
46911		- state.addr = 18446744073709548832LLU; // 99999999Te'''''''''''''''
	46138	+ state.addr = 18446744073709548879LLU; // 99999999UO'''''''''''''''
46912	46139	break;
46913	46140	}
46914		- case 18446744073709548832LLU: // 99999999Te'''''''''''''''
	46141	+ case 18446744073709548879LLU: // 99999999UO'''''''''''''''
46915	46142	{
46916	46143	fprintf(stdout, "%s", ", &value");
46917	46144	fprintf(stdout, "%s", ");");

		@@ -46921,7 +46148,7 @@
46921	46148	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46922	46149	}
46923	46150	// ACCUMULATE ARGUMENTS - END
46924		- uint64_t return_to = 18446744073709548829LLU;
	46151	+ uint64_t return_to = 18446744073709548876LLU;
46925	46152	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46926	46153	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46927	46154	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46930,21 +46157,21 @@
46930	46157	state.addr = 660197403663532032LLU; // indent____
46931	46158	break;
46932	46159	}
46933		- case 18446744073709548829LLU: // 99999999Tb'''''''''''''''
	46160	+ case 18446744073709548876LLU: // 99999999UL'''''''''''''''
46934	46161	{
46935		- state.addr = 18446744073709548830LLU; // 99999999Tc'''''''''''''''
	46162	+ state.addr = 18446744073709548877LLU; // 99999999UM'''''''''''''''
46936	46163	break;
46937	46164	}
46938		- case 18446744073709548830LLU: // 99999999Tc'''''''''''''''
	46165	+ case 18446744073709548877LLU: // 99999999UM'''''''''''''''
46939	46166	{
46940	46167	fprintf(stdout, "%s", " }");
46941	46168	// variable u64 nr________ goes out of scope
46942	46169	// emitted destructur for type u64
46943	46170	(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'''''''''''''''
46945	46172	break;
46946	46173	}
46947		- case 18446744073709548843LLU: // 99999999Tp'''''''''''''''
	46174	+ case 18446744073709548890LLU: // 99999999UZ'''''''''''''''
46948	46175	{
46949	46176	// variable u64 matchsym__ goes out of scope
46950	46177	// emitted destructur for type u64

		@@ -46952,18 +46179,18 @@
46952	46179	// variable u64 sym_______ goes out of scope
46953	46180	// emitted destructur for type u64
46954	46181	(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'''''''''''''''
46956	46183	break;
46957	46184	}
46958		- case 18446744073709548880LLU: // 99999999UP'''''''''''''''
	46185	+ case 18446744073709548927LLU: // 99999999U9'''''''''''''''
46959	46186	{
46960	46187	++/paridx____/*LOCAL_ACCESS(heap.data, 25LLU, 22LLU);
46961	46188	// parameter-reference pardef____ elem______ goes out of scope
46962	46189	// parameter list<pardef____> elems_____ goes out of scope
46963		- state.addr = 18446744073709548886LLU; // 99999999UV'''''''''''''''
	46190	+ state.addr = 18446744073709548933LLU; // 99999999VE'''''''''''''''
46964	46191	break;
46965	46192	}
46966		- case 18446744073709548885LLU: // 99999999UU'''''''''''''''
	46193	+ case 18446744073709548932LLU: // 99999999VD'''''''''''''''
46967	46194	{
46968	46195	fprintf(stdout, "%s", ";");
46969	46196	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46972,7 +46199,7 @@
46972	46199	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46973	46200	}
46974	46201	// ACCUMULATE ARGUMENTS - END
46975		- uint64_t return_to = 18446744073709548826LLU;
	46202	+ uint64_t return_to = 18446744073709548873LLU;
46976	46203	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46977	46204	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46978	46205	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46981,12 +46208,12 @@
46981	46208	state.addr = 660197403663532032LLU; // indent____
46982	46209	break;
46983	46210	}
46984		- case 18446744073709548826LLU: // 99999999TZ'''''''''''''''
	46211	+ case 18446744073709548873LLU: // 99999999UI'''''''''''''''
46985	46212	{
46986		- state.addr = 18446744073709548827LLU; // 99999999T$'''''''''''''''
	46213	+ state.addr = 18446744073709548874LLU; // 99999999UJ'''''''''''''''
46987	46214	break;
46988	46215	}
46989		- case 18446744073709548827LLU: // 99999999T$'''''''''''''''
	46216	+ case 18446744073709548874LLU: // 99999999UJ'''''''''''''''
46990	46217	{
46991	46218	fprintf(stdout, "%s", " {");
46992	46219	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46995,7 +46222,7 @@
46995	46222	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46996	46223	}
46997	46224	// ACCUMULATE ARGUMENTS - END
46998		- uint64_t return_to = 18446744073709548824LLU;
	46225	+ uint64_t return_to = 18446744073709548871LLU;
46999	46226	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47000	46227	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47001	46228	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47004,12 +46231,12 @@
47004	46231	state.addr = 660197403663532032LLU; // indent____
47005	46232	break;
47006	46233	}
47007		- case 18446744073709548824LLU: // 99999999TX'''''''''''''''
	46234	+ case 18446744073709548871LLU: // 99999999UG'''''''''''''''
47008	46235	{
47009		- state.addr = 18446744073709548825LLU; // 99999999TY'''''''''''''''
	46236	+ state.addr = 18446744073709548872LLU; // 99999999UH'''''''''''''''
47010	46237	break;
47011	46238	}
47012		- case 18446744073709548825LLU: // 99999999TY'''''''''''''''
	46239	+ case 18446744073709548872LLU: // 99999999UH'''''''''''''''
47013	46240	{
47014	46241	fprintf(stdout, "%s", " uint64_t constridx = ");
47015	46242	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47018,7 +46245,7 @@
47018	46245	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47019	46246	}
47020	46247	// ACCUMULATE ARGUMENTS - END
47021		- uint64_t return_to = 18446744073709548822LLU;
	46248	+ uint64_t return_to = 18446744073709548869LLU;
47022	46249	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47023	46250	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47024	46251	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47027,12 +46254,12 @@
47027	46254	state.addr = 787446708198178816LLU; // printnr___
47028	46255	break;
47029	46256	}
47030		- case 18446744073709548822LLU: // 99999999TV'''''''''''''''
	46257	+ case 18446744073709548869LLU: // 99999999UE'''''''''''''''
47031	46258	{
47032		- state.addr = 18446744073709548823LLU; // 99999999TW'''''''''''''''
	46259	+ state.addr = 18446744073709548870LLU; // 99999999UF'''''''''''''''
47033	46260	break;
47034	46261	}
47035		- case 18446744073709548823LLU: // 99999999TW'''''''''''''''
	46262	+ case 18446744073709548870LLU: // 99999999UF'''''''''''''''
47036	46263	{
47037	46264	fprintf(stdout, "%s", "; // ");
47038	46265	printid(stdout, /constrid__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 3LLU)));

		@@ -47042,7 +46269,7 @@
47042	46269	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47043	46270	}
47044	46271	// ACCUMULATE ARGUMENTS - END
47045		- uint64_t return_to = 18446744073709548820LLU;
	46272	+ uint64_t return_to = 18446744073709548867LLU;
47046	46273	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47047	46274	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47048	46275	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47051,12 +46278,12 @@
47051	46278	state.addr = 660197403663532032LLU; // indent____
47052	46279	break;
47053	46280	}
47054		- case 18446744073709548820LLU: // 99999999TT'''''''''''''''
	46281	+ case 18446744073709548867LLU: // 99999999UC'''''''''''''''
47055	46282	{
47056		- state.addr = 18446744073709548821LLU; // 99999999TU'''''''''''''''
	46283	+ state.addr = 18446744073709548868LLU; // 99999999UD'''''''''''''''
47057	46284	break;
47058	46285	}
47059		- case 18446744073709548821LLU: // 99999999TU'''''''''''''''
	46286	+ case 18446744073709548868LLU: // 99999999UD'''''''''''''''
47060	46287	{
47061	46288	fprintf(stdout, "%s", " arg");
47062	46289	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47065,7 +46292,7 @@
47065	46292	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47066	46293	}
47067	46294	// ACCUMULATE ARGUMENTS - END
47068		- uint64_t return_to = 18446744073709548818LLU;
	46295	+ uint64_t return_to = 18446744073709548865LLU;
47069	46296	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47070	46297	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47071	46298	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47074,12 +46301,12 @@
47074	46301	state.addr = 787446708200409962LLU; // printnzero
47075	46302	break;
47076	46303	}
47077		- case 18446744073709548818LLU: // 99999999TR'''''''''''''''
	46304	+ case 18446744073709548865LLU: // 99999999UA'''''''''''''''
47078	46305	{
47079		- state.addr = 18446744073709548819LLU; // 99999999TS'''''''''''''''
	46306	+ state.addr = 18446744073709548866LLU; // 99999999UB'''''''''''''''
47080	46307	break;
47081	46308	}
47082		- case 18446744073709548819LLU: // 99999999TS'''''''''''''''
	46309	+ case 18446744073709548866LLU: // 99999999UB'''''''''''''''
47083	46310	{
47084	46311	fprintf(stdout, "%s", " = pair_move(&heap, &constridx, &arg");
47085	46312	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47088,7 +46315,7 @@
47088	46315	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47089	46316	}
47090	46317	// ACCUMULATE ARGUMENTS - END
47091		- uint64_t return_to = 18446744073709548816LLU;
	46318	+ uint64_t return_to = 18446744073709548863LLU;
47092	46319	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47093	46320	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47094	46321	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47097,12 +46324,12 @@
47097	46324	state.addr = 787446708200409962LLU; // printnzero
47098	46325	break;
47099	46326	}
47100		- case 18446744073709548816LLU: // 99999999TP'''''''''''''''
	46327	+ case 18446744073709548863LLU: // 99999999T9'''''''''''''''
47101	46328	{
47102		- state.addr = 18446744073709548817LLU; // 99999999TQ'''''''''''''''
	46329	+ state.addr = 18446744073709548864LLU; // 99999999U_'''''''''''''''
47103	46330	break;
47104	46331	}
47105		- case 18446744073709548817LLU: // 99999999TQ'''''''''''''''
	46332	+ case 18446744073709548864LLU: // 99999999U_'''''''''''''''
47106	46333	{
47107	46334	fprintf(stdout, "%s", ");");
47108	46335	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47111,7 +46338,7 @@
47111	46338	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47112	46339	}
47113	46340	// ACCUMULATE ARGUMENTS - END
47114		- uint64_t return_to = 18446744073709548814LLU;
	46341	+ uint64_t return_to = 18446744073709548861LLU;
47115	46342	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47116	46343	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47117	46344	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47120,18 +46347,18 @@
47120	46347	state.addr = 660197403663532032LLU; // indent____
47121	46348	break;
47122	46349	}
47123		- case 18446744073709548814LLU: // 99999999TN'''''''''''''''
	46350	+ case 18446744073709548861LLU: // 99999999T7'''''''''''''''
47124	46351	{
47125		- state.addr = 18446744073709548815LLU; // 99999999TO'''''''''''''''
	46352	+ state.addr = 18446744073709548862LLU; // 99999999T8'''''''''''''''
47126	46353	break;
47127	46354	}
47128		- case 18446744073709548815LLU: // 99999999TO'''''''''''''''
	46355	+ case 18446744073709548862LLU: // 99999999T8'''''''''''''''
47129	46356	{
47130	46357	fprintf(stdout, "%s", " }");
47131		- state.addr = 18446744073709548828LLU; // 99999999Ta'''''''''''''''
	46358	+ state.addr = 18446744073709548875LLU; // 99999999UK'''''''''''''''
47132	46359	break;
47133	46360	}
47134		- case 18446744073709548828LLU: // 99999999Ta'''''''''''''''
	46361	+ case 18446744073709548875LLU: // 99999999UK'''''''''''''''
47135	46362	{
47136	46363	// variable u64 paridx____ goes out of scope
47137	46364	// emitted destructur for type u64

		@@ -47146,10 +46373,10 @@
47146	46373	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constrs___ at 20
47147	46374	heap.availilable_size_for_dynamic_objects += 0LLU;
47148	46375	heap.availilable_size_for_dynamic_objects += 0LLU;
47149		- state.addr = 18446744073709548813LLU; // 99999999TM'''''''''''''''
	46376	+ state.addr = 18446744073709548860LLU; // 99999999T6'''''''''''''''
47150	46377	break;
47151	46378	}
47152		- case 18446744073709548900LLU: // 99999999Ui'''''''''''''''
	46379	+ case 18446744073709548947LLU: // 99999999VS'''''''''''''''
47153	46380	{
47154	46381	// ACCUMULATE ARGUMENTS - BEGIN
47155	46382	{

		@@ -47169,7 +46396,7 @@
47169	46396	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47170	46397	}
47171	46398	// ACCUMULATE ARGUMENTS - END
47172		- uint64_t return_to = 18446744073709548811LLU;
	46399	+ uint64_t return_to = 18446744073709548858LLU;
47173	46400	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47174	46401	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47175	46402	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47178,17 +46405,17 @@
47178	46405	state.addr = 621706727380746240LLU; // gettk_____
47179	46406	break;
47180	46407	}
47181		- case 18446744073709548811LLU: // 99999999TK'''''''''''''''
	46408	+ case 18446744073709548858LLU: // 99999999T4'''''''''''''''
47182	46409	{
47183		- state.addr = 18446744073709548812LLU; // 99999999TL'''''''''''''''
	46410	+ state.addr = 18446744073709548859LLU; // 99999999T5'''''''''''''''
47184	46411	break;
47185	46412	}
47186		- case 18446744073709548812LLU: // 99999999TL'''''''''''''''
	46413	+ case 18446744073709548859LLU: // 99999999T5'''''''''''''''
47187	46414	{
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;
47189	46416	break;
47190	46417	}
47191		- case 18446744073709548810LLU: // 99999999TJ'''''''''''''''
	46418	+ case 18446744073709548857LLU: // 99999999T3'''''''''''''''
47192	46419	{
47193	46420	{
47194	46421	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 @@
47204	46431	uint64_t arg = 0;
47205	46432	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
47206	46433	}
47207		- state.addr = 18446744073709548808LLU; // 99999999TH'''''''''''''''
	46434	+ state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
47208	46435	break;
47209	46436	}
47210		- case 18446744073709548808LLU: // 99999999TH'''''''''''''''
	46437	+ case 18446744073709548855LLU: // 99999999T1'''''''''''''''
47211	46438	{
47212	46439	if(!*LOCAL_ACCESS(heap.data, 22LLU, 20LLU))
47213	46440	{

		@@ -47214,7 +46441,7 @@
47214	46441	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
47215	46442	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
47216	46443	{
47217		- state.addr = 18446744073709548807LLU; // 99999999TG'''''''''''''''
	46444	+ state.addr = 18446744073709548854LLU; // 99999999T0'''''''''''''''
47218	46445	break;
47219	46446	}
47220	46447	}

		@@ -47242,7 +46469,7 @@
47242	46469	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47243	46470	}
47244	46471	// ACCUMULATE ARGUMENTS - END
47245		- uint64_t return_to = 18446744073709548805LLU;
	46472	+ uint64_t return_to = 18446744073709548852LLU;
47246	46473	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
47247	46474	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47248	46475	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47251,12 +46478,12 @@
47251	46478	state.addr = 367395560426147840LLU; // TYPECOPY__
47252	46479	break;
47253	46480	}
47254		- case 18446744073709548805LLU: // 99999999TE'''''''''''''''
	46481	+ case 18446744073709548852LLU: // 99999999Ty'''''''''''''''
47255	46482	{
47256		- state.addr = 18446744073709548806LLU; // 99999999TF'''''''''''''''
	46483	+ state.addr = 18446744073709548853LLU; // 99999999Tz'''''''''''''''
47257	46484	break;
47258	46485	}
47259		- case 18446744073709548806LLU: // 99999999TF'''''''''''''''
	46486	+ case 18446744073709548853LLU: // 99999999Tz'''''''''''''''
47260	46487	{
47261	46488	{
47262	46489	uint64_t arg = 0;

		@@ -47270,10 +46497,10 @@
47270	46497	};
47271	46498	*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = arg;
47272	46499	}
47273		- state.addr = 18446744073709548804LLU; // 99999999TD'''''''''''''''
	46500	+ state.addr = 18446744073709548851LLU; // 99999999Tx'''''''''''''''
47274	46501	break;
47275	46502	}
47276		- case 18446744073709548804LLU: // 99999999TD'''''''''''''''
	46503	+ case 18446744073709548851LLU: // 99999999Tx'''''''''''''''
47277	46504	{
47278	46505	{
47279	46506	uint64_t arg = 0;

		@@ -47287,15 +46514,15 @@
47287	46514	tree_push_move(&heap, 3LLU, &arg, &*LOCAL_ACCESS(heap.data, 27LLU, 23LLU));
47288	46515	*LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = arg;
47289	46516	}
47290		- state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
	46517	+ state.addr = 18446744073709548850LLU; // 99999999Tw'''''''''''''''
47291	46518	break;
47292	46519	}
47293		- case 18446744073709548803LLU: // 99999999TC'''''''''''''''
	46520	+ case 18446744073709548850LLU: // 99999999Tw'''''''''''''''
47294	46521	{
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;
47296	46523	break;
47297	46524	}
47298		- case 18446744073709548802LLU: // 99999999TB'''''''''''''''
	46525	+ case 18446744073709548849LLU: // 99999999Tv'''''''''''''''
47299	46526	{
47300	46527	{
47301	46528	uint64_t arg = *LOCAL_ACCESS(heap.data, 27LLU, 26LLU);

		@@ -47308,7 +46535,7 @@
47308	46535	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47309	46536	}
47310	46537	// ACCUMULATE ARGUMENTS - END
47311		- uint64_t return_to = 18446744073709548799LLU;
	46538	+ uint64_t return_to = 18446744073709548846LLU;
47312	46539	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47313	46540	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47314	46541	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47317,12 +46544,12 @@
47317	46544	state.addr = 819847183518878432LLU; // reporttype
47318	46545	break;
47319	46546	}
47320		- case 18446744073709548799LLU: // 99999999S9'''''''''''''''
	46547	+ case 18446744073709548846LLU: // 99999999Ts'''''''''''''''
47321	46548	{
47322		- state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
	46549	+ state.addr = 18446744073709548847LLU; // 99999999Tt'''''''''''''''
47323	46550	break;
47324	46551	}
47325		- case 18446744073709548800LLU: // 99999999T_'''''''''''''''
	46552	+ case 18446744073709548847LLU: // 99999999Tt'''''''''''''''
47326	46553	{
47327	46554	fprintf(stderr, "%s", "\n");
47328	46555	{

		@@ -47337,7 +46564,7 @@
47337	46564	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47338	46565	}
47339	46566	// ACCUMULATE ARGUMENTS - END
47340		- uint64_t return_to = 18446744073709548798LLU;
	46567	+ uint64_t return_to = 18446744073709548845LLU;
47341	46568	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47342	46569	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47343	46570	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47346,20 +46573,20 @@
47346	46573	state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
47347	46574	break;
47348	46575	}
47349		- case 18446744073709548798LLU: // 99999999S8'''''''''''''''
	46576	+ case 18446744073709548845LLU: // 99999999Tr'''''''''''''''
47350	46577	{
47351	46578	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newpar____ at 28
47352	46579	heap.availilable_size_for_dynamic_objects += 0LLU;
47353	46580	heap.availilable_size_for_dynamic_objects += 0LLU;
47354		- state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
	46581	+ state.addr = 18446744073709548844LLU; // 99999999Tq'''''''''''''''
47355	46582	break;
47356	46583	}
47357		- case 18446744073709548801LLU: // 99999999TA'''''''''''''''
	46584	+ case 18446744073709548848LLU: // 99999999Tu'''''''''''''''
47358	46585	{
47359		- state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
	46586	+ state.addr = 18446744073709548844LLU; // 99999999Tq'''''''''''''''
47360	46587	break;
47361	46588	}
47362		- case 18446744073709548797LLU: // 99999999S7'''''''''''''''
	46589	+ case 18446744073709548844LLU: // 99999999Tq'''''''''''''''
47363	46590	{
47364	46591	// variable pardef____ newpar____ goes out of scope
47365	46592	// (uninitialized -> no destructor-call)

		@@ -47378,10 +46605,10 @@
47378	46605	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 23
47379	46606	// parameter-reference elemdef___ par_______ goes out of scope
47380	46607	// parameter-reference list<elemdef___> defpars___ goes out of scope
47381		- state.addr = 18446744073709548808LLU; // 99999999TH'''''''''''''''
	46608	+ state.addr = 18446744073709548855LLU; // 99999999T1'''''''''''''''
47382	46609	break;
47383	46610	}
47384		- case 18446744073709548807LLU: // 99999999TG'''''''''''''''
	46611	+ case 18446744073709548854LLU: // 99999999T0'''''''''''''''
47385	46612	{
47386	46613	list_reverse(heap.data, &/elems_____/*LOCAL_ACCESS(heap.data, 20LLU, 13LLU));
47387	46614	{

		@@ -47401,10 +46628,10 @@
47401	46628	};
47402	46629	*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = arg;
47403	46630	}
47404		- state.addr = 18446744073709548796LLU; // 99999999S6'''''''''''''''
	46631	+ state.addr = 18446744073709548843LLU; // 99999999Tp'''''''''''''''
47405	46632	break;
47406	46633	}
47407		- case 18446744073709548796LLU: // 99999999S6'''''''''''''''
	46634	+ case 18446744073709548843LLU: // 99999999Tp'''''''''''''''
47408	46635	{
47409	46636	// ACCUMULATE ARGUMENTS - BEGIN
47410	46637	{

		@@ -47424,7 +46651,7 @@
47424	46651	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47425	46652	}
47426	46653	// ACCUMULATE ARGUMENTS - END
47427		- uint64_t return_to = 18446744073709548794LLU;
	46654	+ uint64_t return_to = 18446744073709548841LLU;
47428	46655	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47429	46656	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47430	46657	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47433,12 +46660,12 @@
47433	46660	state.addr = 861504774606571689LLU; // typeassign
47434	46661	break;
47435	46662	}
47436		- case 18446744073709548794LLU: // 99999999S4'''''''''''''''
	46663	+ case 18446744073709548841LLU: // 99999999Tn'''''''''''''''
47437	46664	{
47438		- state.addr = 18446744073709548795LLU; // 99999999S5'''''''''''''''
	46665	+ state.addr = 18446744073709548842LLU; // 99999999To'''''''''''''''
47439	46666	break;
47440	46667	}
47441		- case 18446744073709548795LLU: // 99999999S5'''''''''''''''
	46668	+ case 18446744073709548842LLU: // 99999999To'''''''''''''''
47442	46669	{
47443	46670	// variable type______ srctype___ goes out of scope
47444	46671	// emitted destructur for type type______

		@@ -47448,7 +46675,7 @@
47448	46675	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47449	46676	}
47450	46677	// ACCUMULATE ARGUMENTS - END
47451		- uint64_t return_to = 18446744073709548793LLU;
	46678	+ uint64_t return_to = 18446744073709548840LLU;
47452	46679	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47453	46680	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47454	46681	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47457,7 +46684,7 @@
47457	46684	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
47458	46685	break;
47459	46686	}
47460		- case 18446744073709548793LLU: // 99999999S3'''''''''''''''
	46687	+ case 18446744073709548840LLU: // 99999999Tm'''''''''''''''
47461	46688	{
47462	46689	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srctype___ at 22
47463	46690	// variable u64 constrid__ goes out of scope

		@@ -47467,10 +46694,10 @@
47467	46694	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defpars___ at 20
47468	46695	heap.availilable_size_for_dynamic_objects += 0LLU;
47469	46696	heap.availilable_size_for_dynamic_objects += 0LLU;
47470		- state.addr = 18446744073709548792LLU; // 99999999S2'''''''''''''''
	46697	+ state.addr = 18446744073709548839LLU; // 99999999Tl'''''''''''''''
47471	46698	break;
47472	46699	}
47473		- case 18446744073709548809LLU: // 99999999TI'''''''''''''''
	46700	+ case 18446744073709548856LLU: // 99999999T2'''''''''''''''
47474	46701	{
47475	46702	// ACCUMULATE ARGUMENTS - BEGIN
47476	46703	{

		@@ -47478,7 +46705,7 @@
47478	46705	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47479	46706	}
47480	46707	// ACCUMULATE ARGUMENTS - END
47481		- uint64_t return_to = 18446744073709548790LLU;
	46708	+ uint64_t return_to = 18446744073709548837LLU;
47482	46709	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47483	46710	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47484	46711	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47487,12 +46714,12 @@
47487	46714	state.addr = 819847183515949359LLU; // reportinit
47488	46715	break;
47489	46716	}
47490		- case 18446744073709548790LLU: // 99999999S0'''''''''''''''
	46717	+ case 18446744073709548837LLU: // 99999999Tj'''''''''''''''
47491	46718	{
47492		- state.addr = 18446744073709548791LLU; // 99999999S1'''''''''''''''
	46719	+ state.addr = 18446744073709548838LLU; // 99999999Tk'''''''''''''''
47493	46720	break;
47494	46721	}
47495		- case 18446744073709548791LLU: // 99999999S1'''''''''''''''
	46722	+ case 18446744073709548838LLU: // 99999999Tk'''''''''''''''
47496	46723	{
47497	46724	// ACCUMULATE ARGUMENTS - BEGIN
47498	46725	{

		@@ -47500,7 +46727,7 @@
47500	46727	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47501	46728	}
47502	46729	// ACCUMULATE ARGUMENTS - END
47503		- uint64_t return_to = 18446744073709548788LLU;
	46730	+ uint64_t return_to = 18446744073709548835LLU;
47504	46731	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47505	46732	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47506	46733	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47509,12 +46736,12 @@
47509	46736	state.addr = 819847183518878432LLU; // reporttype
47510	46737	break;
47511	46738	}
47512		- case 18446744073709548788LLU: // 99999999Sy'''''''''''''''
	46739	+ case 18446744073709548835LLU: // 99999999Th'''''''''''''''
47513	46740	{
47514		- state.addr = 18446744073709548789LLU; // 99999999Sz'''''''''''''''
	46741	+ state.addr = 18446744073709548836LLU; // 99999999Ti'''''''''''''''
47515	46742	break;
47516	46743	}
47517		- case 18446744073709548789LLU: // 99999999Sz'''''''''''''''
	46744	+ case 18446744073709548836LLU: // 99999999Ti'''''''''''''''
47518	46745	{
47519	46746	fprintf(stderr, "%s", " ");
47520	46747	printid(stderr, /constrid__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 3LLU)));

		@@ -47523,10 +46750,10 @@
47523	46750	fprintf(stderr, "%s\n", "");
47524	46751	exit(-1);
47525	46752	}
47526		- state.addr = 18446744073709548792LLU; // 99999999S2'''''''''''''''
	46753	+ state.addr = 18446744073709548839LLU; // 99999999Tl'''''''''''''''
47527	46754	break;
47528	46755	}
47529		- case 18446744073709548792LLU: // 99999999S2'''''''''''''''
	46756	+ case 18446744073709548839LLU: // 99999999Tl'''''''''''''''
47530	46757	{
47531	46758	{
47532	46759	uint64_t arg = 0LLU;

		@@ -47540,10 +46767,10 @@
47540	46767	uint64_t arg = 0;
47541	46768	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
47542	46769	}
47543		- state.addr = 18446744073709548787LLU; // 99999999Sx'''''''''''''''
	46770	+ state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
47544	46771	break;
47545	46772	}
47546		- case 18446744073709548787LLU: // 99999999Sx'''''''''''''''
	46773	+ case 18446744073709548834LLU: // 99999999Tg'''''''''''''''
47547	46774	{
47548	46775	if(!*LOCAL_ACCESS(heap.data, 22LLU, 20LLU))
47549	46776	{

		@@ -47550,16 +46777,16 @@
47550	46777	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
47551	46778	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
47552	46779	{
47553		- state.addr = 18446744073709548786LLU; // 99999999Sw'''''''''''''''
	46780	+ state.addr = 18446744073709548833LLU; // 99999999Tf'''''''''''''''
47554	46781	break;
47555	46782	}
47556	46783	}
47557	46784	/direct/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = (LOCAL_ACCESS(heap.data, 22LLU, 20LLU) << 1) + 1LLU;
47558	46785	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;
47560	46787	break;
47561	46788	}
47562		- case 18446744073709548785LLU: // 99999999Sv'''''''''''''''
	46789	+ case 18446744073709548832LLU: // 99999999Te'''''''''''''''
47563	46790	{
47564	46791	// ACCUMULATE ARGUMENTS - BEGIN
47565	46792	{

		@@ -47567,7 +46794,7 @@
47567	46794	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47568	46795	}
47569	46796	// ACCUMULATE ARGUMENTS - END
47570		- uint64_t return_to = 18446744073709548782LLU;
	46797	+ uint64_t return_to = 18446744073709548829LLU;
47571	46798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47572	46799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47573	46800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47576,18 +46803,18 @@
47576	46803	state.addr = 839519719621918720LLU; // skipws____
47577	46804	break;
47578	46805	}
47579		- case 18446744073709548782LLU: // 99999999Ss'''''''''''''''
	46806	+ case 18446744073709548829LLU: // 99999999Tb'''''''''''''''
47580	46807	{
47581		- state.addr = 18446744073709548783LLU; // 99999999St'''''''''''''''
	46808	+ state.addr = 18446744073709548830LLU; // 99999999Tc'''''''''''''''
47582	46809	break;
47583	46810	}
47584		- case 18446744073709548783LLU: // 99999999St'''''''''''''''
	46811	+ case 18446744073709548830LLU: // 99999999Tc'''''''''''''''
47585	46812	{
47586	46813	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
47587		- state.addr = 18446744073709548784LLU; // 99999999Su'''''''''''''''
	46814	+ state.addr = 18446744073709548831LLU; // 99999999Td'''''''''''''''
47588	46815	break;
47589	46816	}
47590		- case 18446744073709548784LLU: // 99999999Su'''''''''''''''
	46817	+ case 18446744073709548831LLU: // 99999999Td'''''''''''''''
47591	46818	{
47592	46819	{
47593	46820	uint64_t arg = 0LLU;

		@@ -47603,7 +46830,7 @@
47603	46830	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47604	46831	}
47605	46832	// ACCUMULATE ARGUMENTS - END
47606		- uint64_t return_to = 18446744073709548779LLU;
	46833	+ uint64_t return_to = 18446744073709548826LLU;
47607	46834	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47608	46835	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47609	46836	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47612,12 +46839,12 @@
47612	46839	state.addr = 839519719621918720LLU; // skipws____
47613	46840	break;
47614	46841	}
47615		- case 18446744073709548779LLU: // 99999999Sp'''''''''''''''
	46842	+ case 18446744073709548826LLU: // 99999999TZ'''''''''''''''
47616	46843	{
47617		- state.addr = 18446744073709548780LLU; // 99999999Sq'''''''''''''''
	46844	+ state.addr = 18446744073709548827LLU; // 99999999T$'''''''''''''''
47618	46845	break;
47619	46846	}
47620		- case 18446744073709548780LLU: // 99999999Sq'''''''''''''''
	46847	+ case 18446744073709548827LLU: // 99999999T$'''''''''''''''
47621	46848	{
47622	46849	// ACCUMULATE ARGUMENTS - BEGIN
47623	46850	{

		@@ -47629,7 +46856,7 @@
47629	46856	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47630	46857	}
47631	46858	// ACCUMULATE ARGUMENTS - END
47632		- uint64_t return_to = 18446744073709548777LLU;
	46859	+ uint64_t return_to = 18446744073709548824LLU;
47633	46860	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
47634	46861	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47635	46862	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47638,17 +46865,17 @@
47638	46865	state.addr = 661592067397386240LLU; // isalpha___
47639	46866	break;
47640	46867	}
47641		- case 18446744073709548777LLU: // 99999999Sn'''''''''''''''
	46868	+ case 18446744073709548824LLU: // 99999999TX'''''''''''''''
47642	46869	{
47643		- state.addr = 18446744073709548778LLU; // 99999999So'''''''''''''''
	46870	+ state.addr = 18446744073709548825LLU; // 99999999TY'''''''''''''''
47644	46871	break;
47645	46872	}
47646		- case 18446744073709548778LLU: // 99999999So'''''''''''''''
	46873	+ case 18446744073709548825LLU: // 99999999TY'''''''''''''''
47647	46874	{
47648		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) ? 18446744073709548776LLU : 18446744073709548775LLU;
	46875	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) ? 18446744073709548823LLU : 18446744073709548822LLU;
47649	46876	break;
47650	46877	}
47651		- case 18446744073709548776LLU: // 99999999Sm'''''''''''''''
	46878	+ case 18446744073709548823LLU: // 99999999TW'''''''''''''''
47652	46879	{
47653	46880	{
47654	46881	uint64_t arg = 0LLU;

		@@ -47660,7 +46887,7 @@
47660	46887	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47661	46888	}
47662	46889	// ACCUMULATE ARGUMENTS - END
47663		- uint64_t return_to = 18446744073709548773LLU;
	46890	+ uint64_t return_to = 18446744073709548820LLU;
47664	46891	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47665	46892	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47666	46893	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47669,12 +46896,12 @@
47669	46896	state.addr = 839519719621918720LLU; // skipws____
47670	46897	break;
47671	46898	}
47672		- case 18446744073709548773LLU: // 99999999Sj'''''''''''''''
	46899	+ case 18446744073709548820LLU: // 99999999TT'''''''''''''''
47673	46900	{
47674		- state.addr = 18446744073709548774LLU; // 99999999Sk'''''''''''''''
	46901	+ state.addr = 18446744073709548821LLU; // 99999999TU'''''''''''''''
47675	46902	break;
47676	46903	}
47677		- case 18446744073709548774LLU: // 99999999Sk'''''''''''''''
	46904	+ case 18446744073709548821LLU: // 99999999TU'''''''''''''''
47678	46905	{
47679	46906	/argid_____/LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)));
47680	46907	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47683,7 +46910,7 @@
47683	46910	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47684	46911	}
47685	46912	// ACCUMULATE ARGUMENTS - END
47686		- uint64_t return_to = 18446744073709548771LLU;
	46913	+ uint64_t return_to = 18446744073709548818LLU;
47687	46914	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47688	46915	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47689	46916	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47692,12 +46919,12 @@
47692	46919	state.addr = 839519719621918720LLU; // skipws____
47693	46920	break;
47694	46921	}
47695		- case 18446744073709548771LLU: // 99999999Sh'''''''''''''''
	46922	+ case 18446744073709548818LLU: // 99999999TR'''''''''''''''
47696	46923	{
47697		- state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
	46924	+ state.addr = 18446744073709548819LLU; // 99999999TS'''''''''''''''
47698	46925	break;
47699	46926	}
47700		- case 18446744073709548772LLU: // 99999999Si'''''''''''''''
	46927	+ case 18446744073709548819LLU: // 99999999TS'''''''''''''''
47701	46928	{
47702	46929	*LOCAL_ACCESS(heap.data, 25LLU, 22LLU) = 40LLU;
47703	46930

		@@ -47719,7 +46946,7 @@
47719	46946	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47720	46947	}
47721	46948	// ACCUMULATE ARGUMENTS - END
47722		- uint64_t return_to = 18446744073709548769LLU;
	46949	+ uint64_t return_to = 18446744073709548816LLU;
47723	46950	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
47724	46951	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47725	46952	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47728,22 +46955,22 @@
47728	46955	state.addr = 728666047794575267LLU; // matchoptch
47729	46956	break;
47730	46957	}
47731		- case 18446744073709548769LLU: // 99999999Sf'''''''''''''''
	46958	+ case 18446744073709548816LLU: // 99999999TP'''''''''''''''
47732	46959	{
47733		- state.addr = 18446744073709548770LLU; // 99999999Sg'''''''''''''''
	46960	+ state.addr = 18446744073709548817LLU; // 99999999TQ'''''''''''''''
47734	46961	break;
47735	46962	}
47736		- case 18446744073709548770LLU: // 99999999Sg'''''''''''''''
	46963	+ case 18446744073709548817LLU: // 99999999TQ'''''''''''''''
47737	46964	{
47738		- state.addr = /called____/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548768LLU : 18446744073709548767LLU;
	46965	+ state.addr = /called____/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548815LLU : 18446744073709548814LLU;
47739	46966	break;
47740	46967	}
47741		- case 18446744073709548768LLU: // 99999999Se'''''''''''''''
	46968	+ case 18446744073709548815LLU: // 99999999TO'''''''''''''''
47742	46969	{
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;
47744	46971	break;
47745	46972	}
47746		- case 18446744073709548766LLU: // 99999999Sc'''''''''''''''
	46973	+ case 18446744073709548813LLU: // 99999999TM'''''''''''''''
47747	46974	{
47748	46975
47749	46976	heap.availilable_size_for_dynamic_objects -= (27LLU + 8LLU);

		@@ -47755,7 +46982,7 @@
47755	46982	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47756	46983	}
47757	46984	// ACCUMULATE ARGUMENTS - END
47758		- uint64_t return_to = 18446744073709548763LLU;
	46985	+ uint64_t return_to = 18446744073709548810LLU;
47759	46986	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47760	46987	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47761	46988	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47764,12 +46991,12 @@
47764	46991	state.addr = 819790006513303552LLU; // recopen___
47765	46992	break;
47766	46993	}
47767		- case 18446744073709548763LLU: // 99999999S$'''''''''''''''
	46994	+ case 18446744073709548810LLU: // 99999999TJ'''''''''''''''
47768	46995	{
47769		- state.addr = 18446744073709548764LLU; // 99999999Sa'''''''''''''''
	46996	+ state.addr = 18446744073709548811LLU; // 99999999TK'''''''''''''''
47770	46997	break;
47771	46998	}
47772		- case 18446744073709548764LLU: // 99999999Sa'''''''''''''''
	46999	+ case 18446744073709548811LLU: // 99999999TK'''''''''''''''
47773	47000	{
47774	47001	fprintf(stdout, "%s", "0LLU");
47775	47002	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47822,7 +47049,7 @@
47822	47049	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47823	47050	}
47824	47051	// ACCUMULATE ARGUMENTS - END
47825		- uint64_t return_to = 18446744073709548761LLU;
	47052	+ uint64_t return_to = 18446744073709548808LLU;
47826	47053	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
47827	47054	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47828	47055	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47831,12 +47058,12 @@
47831	47058	state.addr = 54378275173643538LLU; // CALLCONSTR
47832	47059	break;
47833	47060	}
47834		- case 18446744073709548761LLU: // 99999999SY'''''''''''''''
	47061	+ case 18446744073709548808LLU: // 99999999TH'''''''''''''''
47835	47062	{
47836		- state.addr = 18446744073709548762LLU; // 99999999SZ'''''''''''''''
	47063	+ state.addr = 18446744073709548809LLU; // 99999999TI'''''''''''''''
47837	47064	break;
47838	47065	}
47839		- case 18446744073709548762LLU: // 99999999SZ'''''''''''''''
	47066	+ case 18446744073709548809LLU: // 99999999TI'''''''''''''''
47840	47067	{
47841	47068	// ACCUMULATE ARGUMENTS - BEGIN
47842	47069	{

		@@ -47848,7 +47075,7 @@
47848	47075	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47849	47076	}
47850	47077	// ACCUMULATE ARGUMENTS - END
47851		- uint64_t return_to = 18446744073709548759LLU;
	47078	+ uint64_t return_to = 18446744073709548806LLU;
47852	47079	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
47853	47080	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47854	47081	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47857,12 +47084,12 @@
47857	47084	state.addr = 819789177753829376LLU; // recclose__
47858	47085	break;
47859	47086	}
47860		- case 18446744073709548759LLU: // 99999999SW'''''''''''''''
	47087	+ case 18446744073709548806LLU: // 99999999TF'''''''''''''''
47861	47088	{
47862		- state.addr = 18446744073709548760LLU; // 99999999SX'''''''''''''''
	47089	+ state.addr = 18446744073709548807LLU; // 99999999TG'''''''''''''''
47863	47090	break;
47864	47091	}
47865		- case 18446744073709548760LLU: // 99999999SX'''''''''''''''
	47092	+ case 18446744073709548807LLU: // 99999999TG'''''''''''''''
47866	47093	{
47867	47094	// ACCUMULATE ARGUMENTS - BEGIN
47868	47095	{

		@@ -47870,7 +47097,7 @@
47870	47097	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47871	47098	}
47872	47099	// ACCUMULATE ARGUMENTS - END
47873		- uint64_t return_to = 18446744073709548757LLU;
	47100	+ uint64_t return_to = 18446744073709548804LLU;
47874	47101	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47875	47102	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47876	47103	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47879,20 +47106,20 @@
47879	47106	state.addr = 839519719621918720LLU; // skipws____
47880	47107	break;
47881	47108	}
47882		- case 18446744073709548757LLU: // 99999999SU'''''''''''''''
	47109	+ case 18446744073709548804LLU: // 99999999TD'''''''''''''''
47883	47110	{
47884		- state.addr = 18446744073709548758LLU; // 99999999SV'''''''''''''''
	47111	+ state.addr = 18446744073709548805LLU; // 99999999TE'''''''''''''''
47885	47112	break;
47886	47113	}
47887		- case 18446744073709548758LLU: // 99999999SV'''''''''''''''
	47114	+ case 18446744073709548805LLU: // 99999999TE'''''''''''''''
47888	47115	{
47889	47116	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 26LLU, 5LLU)));
47890	47117	heap.availilable_size_for_dynamic_objects += 27LLU;
47891	47118	heap.availilable_size_for_dynamic_objects += 8LLU;
47892		- state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
	47119	+ state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
47893	47120	break;
47894	47121	}
47895		- case 18446744073709548765LLU: // 99999999Sb'''''''''''''''
	47122	+ case 18446744073709548812LLU: // 99999999TL'''''''''''''''
47896	47123	{
47897	47124	// ACCUMULATE ARGUMENTS - BEGIN
47898	47125	{

		@@ -47900,7 +47127,7 @@
47900	47127	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47901	47128	}
47902	47129	// ACCUMULATE ARGUMENTS - END
47903		- uint64_t return_to = 18446744073709548754LLU;
	47130	+ uint64_t return_to = 18446744073709548801LLU;
47904	47131	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47905	47132	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47906	47133	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47909,28 +47136,28 @@
47909	47136	state.addr = 819847183515949359LLU; // reportinit
47910	47137	break;
47911	47138	}
47912		- case 18446744073709548754LLU: // 99999999SR'''''''''''''''
	47139	+ case 18446744073709548801LLU: // 99999999TA'''''''''''''''
47913	47140	{
47914		- state.addr = 18446744073709548755LLU; // 99999999SS'''''''''''''''
	47141	+ state.addr = 18446744073709548802LLU; // 99999999TB'''''''''''''''
47915	47142	break;
47916	47143	}
47917		- case 18446744073709548755LLU: // 99999999SS'''''''''''''''
	47144	+ case 18446744073709548802LLU: // 99999999TB'''''''''''''''
47918	47145	{
47919	47146	{
47920	47147	fprintf(stderr, "%s\n", "[INTERNAL ERROR, CALLCONSTR] out of memory - recompile compiler with increased heap-size");
47921	47148	exit(-1);
47922	47149	}
47923		- state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
	47150	+ state.addr = 18446744073709548803LLU; // 99999999TC'''''''''''''''
47924	47151	break;
47925	47152	}
47926		- case 18446744073709548756LLU: // 99999999ST'''''''''''''''
	47153	+ case 18446744073709548803LLU: // 99999999TC'''''''''''''''
47927	47154	{
47928	47155	heap.availilable_size_for_dynamic_objects += 0LLU;
47929	47156	heap.availilable_size_for_dynamic_objects += 0LLU;
47930		- state.addr = 18446744073709548753LLU; // 99999999SQ'''''''''''''''
	47157	+ state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
47931	47158	break;
47932	47159	}
47933		- case 18446744073709548767LLU: // 99999999Sd'''''''''''''''
	47160	+ case 18446744073709548814LLU: // 99999999TN'''''''''''''''
47934	47161	{
47935	47162	fprintf(stdout, "%s", ";");
47936	47163	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47939,7 +47166,7 @@
47939	47166	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47940	47167	}
47941	47168	// ACCUMULATE ARGUMENTS - END
47942		- uint64_t return_to = 18446744073709548751LLU;
	47169	+ uint64_t return_to = 18446744073709548798LLU;
47943	47170	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47944	47171	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47945	47172	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47948,12 +47175,12 @@
47948	47175	state.addr = 660197403663532032LLU; // indent____
47949	47176	break;
47950	47177	}
47951		- case 18446744073709548751LLU: // 99999999SO'''''''''''''''
	47178	+ case 18446744073709548798LLU: // 99999999S8'''''''''''''''
47952	47179	{
47953		- state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
	47180	+ state.addr = 18446744073709548799LLU; // 99999999S9'''''''''''''''
47954	47181	break;
47955	47182	}
47956		- case 18446744073709548752LLU: // 99999999SP'''''''''''''''
	47183	+ case 18446744073709548799LLU: // 99999999S9'''''''''''''''
47957	47184	{
47958	47185	fprintf(stdout, "%s", " tree_push_move(&heap, ");
47959	47186	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47962,7 +47189,7 @@
47962	47189	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47963	47190	}
47964	47191	// ACCUMULATE ARGUMENTS - END
47965		- uint64_t return_to = 18446744073709548749LLU;
	47192	+ uint64_t return_to = 18446744073709548796LLU;
47966	47193	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47967	47194	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47968	47195	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47971,12 +47198,12 @@
47971	47198	state.addr = 787446708198178816LLU; // printnr___
47972	47199	break;
47973	47200	}
47974		- case 18446744073709548749LLU: // 99999999SM'''''''''''''''
	47201	+ case 18446744073709548796LLU: // 99999999S6'''''''''''''''
47975	47202	{
47976		- state.addr = 18446744073709548750LLU; // 99999999SN'''''''''''''''
	47203	+ state.addr = 18446744073709548797LLU; // 99999999S7'''''''''''''''
47977	47204	break;
47978	47205	}
47979		- case 18446744073709548750LLU: // 99999999SN'''''''''''''''
	47206	+ case 18446744073709548797LLU: // 99999999S7'''''''''''''''
47980	47207	{
47981	47208	fprintf(stdout, "%s", ", &arg");
47982	47209	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47985,7 +47212,7 @@
47985	47212	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47986	47213	}
47987	47214	// ACCUMULATE ARGUMENTS - END
47988		- uint64_t return_to = 18446744073709548747LLU;
	47215	+ uint64_t return_to = 18446744073709548794LLU;
47989	47216	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47990	47217	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47991	47218	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47994,12 +47221,12 @@
47994	47221	state.addr = 787446708200409962LLU; // printnzero
47995	47222	break;
47996	47223	}
47997		- case 18446744073709548747LLU: // 99999999SK'''''''''''''''
	47224	+ case 18446744073709548794LLU: // 99999999S4'''''''''''''''
47998	47225	{
47999		- state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
	47226	+ state.addr = 18446744073709548795LLU; // 99999999S5'''''''''''''''
48000	47227	break;
48001	47228	}
48002		- case 18446744073709548748LLU: // 99999999SL'''''''''''''''
	47229	+ case 18446744073709548795LLU: // 99999999S5'''''''''''''''
48003	47230	{
48004	47231	fprintf(stdout, "%s", ", &");
48005	47232	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48048,7 +47275,7 @@
48048	47275	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48049	47276	}
48050	47277	// ACCUMULATE ARGUMENTS - END
48051		- uint64_t return_to = 18446744073709548745LLU;
	47278	+ uint64_t return_to = 18446744073709548792LLU;
48052	47279	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
48053	47280	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48054	47281	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48057,18 +47284,18 @@
48057	47284	state.addr = 552437436537559168LLU; // constrarg_
48058	47285	break;
48059	47286	}
48060		- case 18446744073709548745LLU: // 99999999SI'''''''''''''''
	47287	+ case 18446744073709548792LLU: // 99999999S2'''''''''''''''
48061	47288	{
48062		- state.addr = 18446744073709548746LLU; // 99999999SJ'''''''''''''''
	47289	+ state.addr = 18446744073709548793LLU; // 99999999S3'''''''''''''''
48063	47290	break;
48064	47291	}
48065		- case 18446744073709548746LLU: // 99999999SJ'''''''''''''''
	47292	+ case 18446744073709548793LLU: // 99999999S3'''''''''''''''
48066	47293	{
48067	47294	fprintf(stdout, "%s", ")");
48068		- state.addr = 18446744073709548753LLU; // 99999999SQ'''''''''''''''
	47295	+ state.addr = 18446744073709548800LLU; // 99999999T_'''''''''''''''
48069	47296	break;
48070	47297	}
48071		- case 18446744073709548753LLU: // 99999999SQ'''''''''''''''
	47298	+ case 18446744073709548800LLU: // 99999999T_'''''''''''''''
48072	47299	{
48073	47300	// variable u64 called____ goes out of scope
48074	47301	// emitted destructur for type u64

		@@ -48078,10 +47305,10 @@
48078	47305	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference argid_____ at 25
48079	47306	heap.availilable_size_for_dynamic_objects += 0LLU;
48080	47307	heap.availilable_size_for_dynamic_objects += 0LLU;
48081		- state.addr = 18446744073709548744LLU; // 99999999SH'''''''''''''''
	47308	+ state.addr = 18446744073709548791LLU; // 99999999S1'''''''''''''''
48082	47309	break;
48083	47310	}
48084		- case 18446744073709548775LLU: // 99999999Sl'''''''''''''''
	47311	+ case 18446744073709548822LLU: // 99999999TV'''''''''''''''
48085	47312	{
48086	47313	{
48087	47314	uint64_t arg = 0LLU;

		@@ -48095,7 +47322,7 @@
48095	47322	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48096	47323	}
48097	47324	// ACCUMULATE ARGUMENTS - END
48098		- uint64_t return_to = 18446744073709548742LLU;
	47325	+ uint64_t return_to = 18446744073709548789LLU;
48099	47326	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48100	47327	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48101	47328	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48104,12 +47331,12 @@
48104	47331	state.addr = 660197403663532032LLU; // indent____
48105	47332	break;
48106	47333	}
48107		- case 18446744073709548742LLU: // 99999999SF'''''''''''''''
	47334	+ case 18446744073709548789LLU: // 99999999Sz'''''''''''''''
48108	47335	{
48109		- state.addr = 18446744073709548743LLU; // 99999999SG'''''''''''''''
	47336	+ state.addr = 18446744073709548790LLU; // 99999999S0'''''''''''''''
48110	47337	break;
48111	47338	}
48112		- case 18446744073709548743LLU: // 99999999SG'''''''''''''''
	47339	+ case 18446744073709548790LLU: // 99999999S0'''''''''''''''
48113	47340	{
48114	47341	fprintf(stdout, "%s", " {");
48115	47342	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48118,7 +47345,7 @@
48118	47345	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48119	47346	}
48120	47347	// ACCUMULATE ARGUMENTS - END
48121		- uint64_t return_to = 18446744073709548740LLU;
	47348	+ uint64_t return_to = 18446744073709548787LLU;
48122	47349	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48123	47350	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48124	47351	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48127,12 +47354,12 @@
48127	47354	state.addr = 660197403663532032LLU; // indent____
48128	47355	break;
48129	47356	}
48130		- case 18446744073709548740LLU: // 99999999SD'''''''''''''''
	47357	+ case 18446744073709548787LLU: // 99999999Sx'''''''''''''''
48131	47358	{
48132		- state.addr = 18446744073709548741LLU; // 99999999SE'''''''''''''''
	47359	+ state.addr = 18446744073709548788LLU; // 99999999Sy'''''''''''''''
48133	47360	break;
48134	47361	}
48135		- case 18446744073709548741LLU: // 99999999SE'''''''''''''''
	47362	+ case 18446744073709548788LLU: // 99999999Sy'''''''''''''''
48136	47363	{
48137	47364	fprintf(stdout, "%s", " uint64_t value = ");
48138	47365	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48141,7 +47368,7 @@
48141	47368	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48142	47369	}
48143	47370	// ACCUMULATE ARGUMENTS - END
48144		- uint64_t return_to = 18446744073709548738LLU;
	47371	+ uint64_t return_to = 18446744073709548785LLU;
48145	47372	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48146	47373	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48147	47374	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48150,12 +47377,12 @@
48150	47377	state.addr = 787446708198178816LLU; // printnr___
48151	47378	break;
48152	47379	}
48153		- case 18446744073709548738LLU: // 99999999SB'''''''''''''''
	47380	+ case 18446744073709548785LLU: // 99999999Sv'''''''''''''''
48154	47381	{
48155		- state.addr = 18446744073709548739LLU; // 99999999SC'''''''''''''''
	47382	+ state.addr = 18446744073709548786LLU; // 99999999Sw'''''''''''''''
48156	47383	break;
48157	47384	}
48158		- case 18446744073709548739LLU: // 99999999SC'''''''''''''''
	47385	+ case 18446744073709548786LLU: // 99999999Sw'''''''''''''''
48159	47386	{
48160	47387	fprintf(stdout, "%s", ";");
48161	47388	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48164,7 +47391,7 @@
48164	47391	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48165	47392	}
48166	47393	// ACCUMULATE ARGUMENTS - END
48167		- uint64_t return_to = 18446744073709548736LLU;
	47394	+ uint64_t return_to = 18446744073709548783LLU;
48168	47395	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48169	47396	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48170	47397	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48173,12 +47400,12 @@
48173	47400	state.addr = 660197403663532032LLU; // indent____
48174	47401	break;
48175	47402	}
48176		- case 18446744073709548736LLU: // 99999999S_'''''''''''''''
	47403	+ case 18446744073709548783LLU: // 99999999St'''''''''''''''
48177	47404	{
48178		- state.addr = 18446744073709548737LLU; // 99999999SA'''''''''''''''
	47405	+ state.addr = 18446744073709548784LLU; // 99999999Su'''''''''''''''
48179	47406	break;
48180	47407	}
48181		- case 18446744073709548737LLU: // 99999999SA'''''''''''''''
	47408	+ case 18446744073709548784LLU: // 99999999Su'''''''''''''''
48182	47409	{
48183	47410	fprintf(stdout, "%s", " tree_push_move(&heap, ");
48184	47411	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48187,7 +47414,7 @@
48187	47414	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48188	47415	}
48189	47416	// ACCUMULATE ARGUMENTS - END
48190		- uint64_t return_to = 18446744073709548734LLU;
	47417	+ uint64_t return_to = 18446744073709548781LLU;
48191	47418	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48192	47419	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48193	47420	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48196,12 +47423,12 @@
48196	47423	state.addr = 787446708198178816LLU; // printnr___
48197	47424	break;
48198	47425	}
48199		- case 18446744073709548734LLU: // 99999999R8'''''''''''''''
	47426	+ case 18446744073709548781LLU: // 99999999Sr'''''''''''''''
48200	47427	{
48201		- state.addr = 18446744073709548735LLU; // 99999999R9'''''''''''''''
	47428	+ state.addr = 18446744073709548782LLU; // 99999999Ss'''''''''''''''
48202	47429	break;
48203	47430	}
48204		- case 18446744073709548735LLU: // 99999999R9'''''''''''''''
	47431	+ case 18446744073709548782LLU: // 99999999Ss'''''''''''''''
48205	47432	{
48206	47433	fprintf(stdout, "%s", ", &arg");
48207	47434	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48210,7 +47437,7 @@
48210	47437	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48211	47438	}
48212	47439	// ACCUMULATE ARGUMENTS - END
48213		- uint64_t return_to = 18446744073709548732LLU;
	47440	+ uint64_t return_to = 18446744073709548779LLU;
48214	47441	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48215	47442	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48216	47443	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48219,12 +47446,12 @@
48219	47446	state.addr = 787446708200409962LLU; // printnzero
48220	47447	break;
48221	47448	}
48222		- case 18446744073709548732LLU: // 99999999R6'''''''''''''''
	47449	+ case 18446744073709548779LLU: // 99999999Sp'''''''''''''''
48223	47450	{
48224		- state.addr = 18446744073709548733LLU; // 99999999R7'''''''''''''''
	47451	+ state.addr = 18446744073709548780LLU; // 99999999Sq'''''''''''''''
48225	47452	break;
48226	47453	}
48227		- case 18446744073709548733LLU: // 99999999R7'''''''''''''''
	47454	+ case 18446744073709548780LLU: // 99999999Sq'''''''''''''''
48228	47455	{
48229	47456	fprintf(stdout, "%s", ", &value");
48230	47457	fprintf(stdout, "%s", ");");

		@@ -48234,7 +47461,7 @@
48234	47461	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48235	47462	}
48236	47463	// ACCUMULATE ARGUMENTS - END
48237		- uint64_t return_to = 18446744073709548730LLU;
	47464	+ uint64_t return_to = 18446744073709548777LLU;
48238	47465	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48239	47466	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48240	47467	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48243,21 +47470,21 @@
48243	47470	state.addr = 660197403663532032LLU; // indent____
48244	47471	break;
48245	47472	}
48246		- case 18446744073709548730LLU: // 99999999R4'''''''''''''''
	47473	+ case 18446744073709548777LLU: // 99999999Sn'''''''''''''''
48247	47474	{
48248		- state.addr = 18446744073709548731LLU; // 99999999R5'''''''''''''''
	47475	+ state.addr = 18446744073709548778LLU; // 99999999So'''''''''''''''
48249	47476	break;
48250	47477	}
48251		- case 18446744073709548731LLU: // 99999999R5'''''''''''''''
	47478	+ case 18446744073709548778LLU: // 99999999So'''''''''''''''
48252	47479	{
48253	47480	fprintf(stdout, "%s", " }");
48254	47481	// variable u64 nr________ goes out of scope
48255	47482	// emitted destructur for type u64
48256	47483	(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'''''''''''''''
48258	47485	break;
48259	47486	}
48260		- case 18446744073709548744LLU: // 99999999SH'''''''''''''''
	47487	+ case 18446744073709548791LLU: // 99999999S1'''''''''''''''
48261	47488	{
48262	47489	// variable u64 matchsym__ goes out of scope
48263	47490	// emitted destructur for type u64

		@@ -48265,35 +47492,35 @@
48265	47492	// variable u64 sym_______ goes out of scope
48266	47493	// emitted destructur for type u64
48267	47494	(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'''''''''''''''
48269	47496	break;
48270	47497	}
48271		- case 18446744073709548781LLU: // 99999999Sr'''''''''''''''
	47498	+ case 18446744073709548828LLU: // 99999999Ta'''''''''''''''
48272	47499	{
48273	47500	++/paridx____/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
48274	47501	// parameter-reference pardef____ elem______ goes out of scope
48275	47502	// parameter list<pardef____> elems_____ goes out of scope
48276		- state.addr = 18446744073709548787LLU; // 99999999Sx'''''''''''''''
	47503	+ state.addr = 18446744073709548834LLU; // 99999999Tg'''''''''''''''
48277	47504	break;
48278	47505	}
48279		- case 18446744073709548786LLU: // 99999999Sw'''''''''''''''
	47506	+ case 18446744073709548833LLU: // 99999999Tf'''''''''''''''
48280	47507	{
48281	47508	// variable u64 paridx____ goes out of scope
48282	47509	// emitted destructur for type u64
48283	47510	(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'''''''''''''''
48285	47512	break;
48286	47513	}
48287		- case 18446744073709548813LLU: // 99999999TM'''''''''''''''
	47514	+ case 18446744073709548860LLU: // 99999999T6'''''''''''''''
48288	47515	{
48289	47516	// parameter-reference u64 SIZEONHEAP goes out of scope
48290	47517	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference SIZEONHEAP at 19
48291	47518	// parameter-reference typekind__ kind______ goes out of scope
48292	47519	(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'''''''''''''''
48294	47521	break;
48295	47522	}
48296		- case 18446744073709548902LLU: // 99999999Uk'''''''''''''''
	47523	+ case 18446744073709548949LLU: // 99999999VU'''''''''''''''
48297	47524	{
48298	47525	// variable typedef___ def_______ goes out of scope
48299	47526	// emitted destructur for type typedef___

		@@ -48303,7 +47530,7 @@
48303	47530	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48304	47531	}
48305	47532	// ACCUMULATE ARGUMENTS - END
48306		- uint64_t return_to = 18446744073709548729LLU;
	47533	+ uint64_t return_to = 18446744073709548776LLU;
48307	47534	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48308	47535	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48309	47536	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48312,7 +47539,7 @@
48312	47539	state.addr = 18446744073709551111LLU; // 999999992G'''''''''''''''
48313	47540	break;
48314	47541	}
48315		- case 18446744073709548729LLU: // 99999999R3'''''''''''''''
	47542	+ case 18446744073709548776LLU: // 99999999Sm'''''''''''''''
48316	47543	{
48317	47544	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference def_______ at 17
48318	47545	// variable u64 calleeacnt goes out of scope

		@@ -48323,14 +47550,14 @@
48323	47550	(void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleesize at 15
48324	47551	// variable list<pardef____> elems_____ goes out of scope
48325	47552	// emitted destructur for type list<pardef____>
48326		- state.addr = 18446744073709548727LLU; // 99999999R1'''''''''''''''
	47553	+ state.addr = 18446744073709548774LLU; // 99999999Sk'''''''''''''''
48327	47554	break;
48328	47555	}
48329		- case 18446744073709548727LLU: // 99999999R1'''''''''''''''
	47556	+ case 18446744073709548774LLU: // 99999999Sk'''''''''''''''
48330	47557	{
48331	47558	if(!LOCAL_ACCESS(heap.data, 14LLU, 13LLU)/list*/)
48332	47559	{
48333		- state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
	47560	+ state.addr = 18446744073709548775LLU; // 99999999Sl'''''''''''''''
48334	47561	break;
48335	47562	}
48336	47563	// temporary list-element

		@@ -48344,7 +47571,7 @@
48344	47571	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48345	47572	}
48346	47573	// ACCUMULATE ARGUMENTS - END
48347		- uint64_t return_to = 18446744073709548726LLU;
	47574	+ uint64_t return_to = 18446744073709548773LLU;
48348	47575	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48349	47576	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48350	47577	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48353,14 +47580,14 @@
48353	47580	state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
48354	47581	break;
48355	47582	}
48356		- case 18446744073709548726LLU: // 99999999R0'''''''''''''''
	47583	+ case 18446744073709548773LLU: // 99999999Sj'''''''''''''''
48357	47584	{
48358	47585	// RELEASE temporary destructor-variable
48359	47586	(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'''''''''''''''
48361	47588	break;
48362	47589	}
48363		- case 18446744073709548728LLU: // 99999999R2'''''''''''''''
	47590	+ case 18446744073709548775LLU: // 99999999Sl'''''''''''''''
48364	47591	{
48365	47592	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference elems_____ at 14
48366	47593	// parameter-reference u64 maintype__ goes out of scope

		@@ -48367,10 +47594,10 @@
48367	47594	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference maintype__ at 13
48368	47595	heap.availilable_size_for_dynamic_objects += 0LLU;
48369	47596	heap.availilable_size_for_dynamic_objects += 0LLU;
48370		- state.addr = 18446744073709548725LLU; // 99999999Rz'''''''''''''''
	47597	+ state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
48371	47598	break;
48372	47599	}
48373		- case 18446744073709548906LLU: // 99999999Uo'''''''''''''''
	47600	+ case 18446744073709548953LLU: // 99999999VY'''''''''''''''
48374	47601	{
48375	47602	// ACCUMULATE ARGUMENTS - BEGIN
48376	47603	{

		@@ -48378,7 +47605,7 @@
48378	47605	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48379	47606	}
48380	47607	// ACCUMULATE ARGUMENTS - END
48381		- uint64_t return_to = 18446744073709548723LLU;
	47608	+ uint64_t return_to = 18446744073709548770LLU;
48382	47609	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48383	47610	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48384	47611	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48387,12 +47614,12 @@
48387	47614	state.addr = 819847183515949359LLU; // reportinit
48388	47615	break;
48389	47616	}
48390		- case 18446744073709548723LLU: // 99999999Rx'''''''''''''''
	47617	+ case 18446744073709548770LLU: // 99999999Sg'''''''''''''''
48391	47618	{
48392		- state.addr = 18446744073709548724LLU; // 99999999Ry'''''''''''''''
	47619	+ state.addr = 18446744073709548771LLU; // 99999999Sh'''''''''''''''
48393	47620	break;
48394	47621	}
48395		- case 18446744073709548724LLU: // 99999999Ry'''''''''''''''
	47622	+ case 18446744073709548771LLU: // 99999999Sh'''''''''''''''
48396	47623	{
48397	47624	fprintf(stderr, "%s", "type ");
48398	47625	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48401,7 +47628,7 @@
48401	47628	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48402	47629	}
48403	47630	// ACCUMULATE ARGUMENTS - END
48404		- uint64_t return_to = 18446744073709548721LLU;
	47631	+ uint64_t return_to = 18446744073709548768LLU;
48405	47632	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48406	47633	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48407	47634	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48410,12 +47637,12 @@
48410	47637	state.addr = 819847183518878432LLU; // reporttype
48411	47638	break;
48412	47639	}
48413		- case 18446744073709548721LLU: // 99999999Rv'''''''''''''''
	47640	+ case 18446744073709548768LLU: // 99999999Se'''''''''''''''
48414	47641	{
48415		- state.addr = 18446744073709548722LLU; // 99999999Rw'''''''''''''''
	47642	+ state.addr = 18446744073709548769LLU; // 99999999Sf'''''''''''''''
48416	47643	break;
48417	47644	}
48418		- case 18446744073709548722LLU: // 99999999Rw'''''''''''''''
	47645	+ case 18446744073709548769LLU: // 99999999Sf'''''''''''''''
48419	47646	{
48420	47647	fprintf(stderr, "%s", " can only be constructed by literals");
48421	47648	{

		@@ -48422,10 +47649,10 @@
48422	47649	fprintf(stderr, "%s\n", "");
48423	47650	exit(-1);
48424	47651	}
48425		- state.addr = 18446744073709548725LLU; // 99999999Rz'''''''''''''''
	47652	+ state.addr = 18446744073709548772LLU; // 99999999Si'''''''''''''''
48426	47653	break;
48427	47654	}
48428		- case 18446744073709548725LLU: // 99999999Rz'''''''''''''''
	47655	+ case 18446744073709548772LLU: // 99999999Si'''''''''''''''
48429	47656	{
48430	47657	// parameter-reference u64 remainsize goes out of scope
48431	47658	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 12

		@@ -48473,10 +47700,10 @@
48473	47700	};
48474	47701	*LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = arg;
48475	47702	}
48476		- state.addr = 18446744073709548720LLU; // 99999999Ru'''''''''''''''
	47703	+ state.addr = 18446744073709548767LLU; // 99999999Sd'''''''''''''''
48477	47704	break;
48478	47705	}
48479		- case 18446744073709548720LLU: // 99999999Ru'''''''''''''''
	47706	+ case 18446744073709548767LLU: // 99999999Sd'''''''''''''''
48480	47707	{
48481	47708	{
48482	47709	uint64_t arg = 0LLU;

		@@ -48556,7 +47783,7 @@
48556	47783	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48557	47784	}
48558	47785	// ACCUMULATE ARGUMENTS - END
48559		- uint64_t return_to = 18446744073709548716LLU;
	47786	+ uint64_t return_to = 18446744073709548763LLU;
48560	47787	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
48561	47788	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48562	47789	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48565,12 +47792,12 @@
48565	47792	state.addr = 604790753280317473LLU; // findvarref
48566	47793	break;
48567	47794	}
48568		- case 18446744073709548716LLU: // 99999999Rq'''''''''''''''
	47795	+ case 18446744073709548763LLU: // 99999999S$'''''''''''''''
48569	47796	{
48570		- state.addr = 18446744073709548717LLU; // 99999999Rr'''''''''''''''
	47797	+ state.addr = 18446744073709548764LLU; // 99999999Sa'''''''''''''''
48571	47798	break;
48572	47799	}
48573		- case 18446744073709548717LLU: // 99999999Rr'''''''''''''''
	47800	+ case 18446744073709548764LLU: // 99999999Sa'''''''''''''''
48574	47801	{
48575	47802	// variable u64 consume___ goes out of scope
48576	47803	// emitted destructur for type u64

		@@ -48578,25 +47805,25 @@
48578	47805	// variable u64 optelem___ goes out of scope
48579	47806	// emitted destructur for type u64
48580	47807	(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'''''''''''''''
48582	47809	break;
48583	47810	}
48584		- case 18446744073709548718LLU: // 99999999Rs'''''''''''''''
	47811	+ case 18446744073709548765LLU: // 99999999Sb'''''''''''''''
48585	47812	{
48586		- state.addr = /initialize/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548715LLU : 18446744073709548714LLU;
	47813	+ state.addr = /initialize/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548762LLU : 18446744073709548761LLU;
48587	47814	break;
48588	47815	}
48589		- case 18446744073709548715LLU: // 99999999Rp'''''''''''''''
	47816	+ case 18446744073709548762LLU: // 99999999SZ'''''''''''''''
48590	47817	{
48591		- state.addr = /mutable___/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548713LLU : 18446744073709548712LLU;
	47818	+ state.addr = /mutable___/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548760LLU : 18446744073709548759LLU;
48592	47819	break;
48593	47820	}
48594		- case 18446744073709548713LLU: // 99999999Rn'''''''''''''''
	47821	+ case 18446744073709548760LLU: // 99999999SX'''''''''''''''
48595	47822	{
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;
48597	47824	break;
48598	47825	}
48599		- case 18446744073709548711LLU: // 99999999Rl'''''''''''''''
	47826	+ case 18446744073709548758LLU: // 99999999SV'''''''''''''''
48600	47827	{
48601	47828	{
48602	47829	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 @@
48619	47846	};
48620	47847	*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = arg;
48621	47848	}
48622		- state.addr = 18446744073709548709LLU; // 99999999Rj'''''''''''''''
	47849	+ state.addr = 18446744073709548756LLU; // 99999999ST'''''''''''''''
48623	47850	break;
48624	47851	}
48625		- case 18446744073709548709LLU: // 99999999Rj'''''''''''''''
	47852	+ case 18446744073709548756LLU: // 99999999ST'''''''''''''''
48626	47853	{
48627	47854	// ACCUMULATE ARGUMENTS - BEGIN
48628	47855	{

		@@ -48662,7 +47889,7 @@
48662	47889	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48663	47890	}
48664	47891	// ACCUMULATE ARGUMENTS - END
48665		- uint64_t return_to = 18446744073709548707LLU;
	47892	+ uint64_t return_to = 18446744073709548754LLU;
48666	47893	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
48667	47894	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48668	47895	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48671,12 +47898,12 @@
48671	47898	state.addr = 587881344696777536LLU; // emitdestr_
48672	47899	break;
48673	47900	}
48674		- case 18446744073709548707LLU: // 99999999Rh'''''''''''''''
	47901	+ case 18446744073709548754LLU: // 99999999SR'''''''''''''''
48675	47902	{
48676		- state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
	47903	+ state.addr = 18446744073709548755LLU; // 99999999SS'''''''''''''''
48677	47904	break;
48678	47905	}
48679		- case 18446744073709548708LLU: // 99999999Ri'''''''''''''''
	47906	+ case 18446744073709548755LLU: // 99999999SS'''''''''''''''
48680	47907	{
48681	47908	// variable type______ TYPEDST___ goes out of scope
48682	47909	// emitted destructur for type type______

		@@ -48686,7 +47913,7 @@
48686	47913	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48687	47914	}
48688	47915	// ACCUMULATE ARGUMENTS - END
48689		- uint64_t return_to = 18446744073709548706LLU;
	47916	+ uint64_t return_to = 18446744073709548753LLU;
48690	47917	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48691	47918	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48692	47919	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48695,7 +47922,7 @@
48695	47922	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
48696	47923	break;
48697	47924	}
48698		- case 18446744073709548706LLU: // 99999999Rg'''''''''''''''
	47925	+ case 18446744073709548753LLU: // 99999999SQ'''''''''''''''
48699	47926	{
48700	47927	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPEDST___ at 22
48701	47928	// variable u64 name______ goes out of scope

		@@ -48705,22 +47932,22 @@
48705	47932	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference name______ at 20
48706	47933	heap.availilable_size_for_dynamic_objects += 0LLU;
48707	47934	heap.availilable_size_for_dynamic_objects += 0LLU;
48708		- state.addr = 18446744073709548705LLU; // 99999999Rf'''''''''''''''
	47935	+ state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
48709	47936	break;
48710	47937	}
48711		- case 18446744073709548710LLU: // 99999999Rk'''''''''''''''
	47938	+ case 18446744073709548757LLU: // 99999999SU'''''''''''''''
48712	47939	{
48713		- state.addr = 18446744073709548705LLU; // 99999999Rf'''''''''''''''
	47940	+ state.addr = 18446744073709548752LLU; // 99999999SP'''''''''''''''
48714	47941	break;
48715	47942	}
48716		- case 18446744073709548705LLU: // 99999999Rf'''''''''''''''
	47943	+ case 18446744073709548752LLU: // 99999999SP'''''''''''''''
48717	47944	{
48718	47945	heap.availilable_size_for_dynamic_objects += 0LLU;
48719	47946	heap.availilable_size_for_dynamic_objects += 0LLU;
48720		- state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
	47947	+ state.addr = 18446744073709548751LLU; // 99999999SO'''''''''''''''
48721	47948	break;
48722	47949	}
48723		- case 18446744073709548712LLU: // 99999999Rm'''''''''''''''
	47950	+ case 18446744073709548759LLU: // 99999999SW'''''''''''''''
48724	47951	{
48725	47952	fprintf(stderr, "%s", "cannot assign to constant ");
48726	47953	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48729,7 +47956,7 @@
48729	47956	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48730	47957	}
48731	47958	// ACCUMULATE ARGUMENTS - END
48732		- uint64_t return_to = 18446744073709548702LLU;
	47959	+ uint64_t return_to = 18446744073709548749LLU;
48733	47960	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48734	47961	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48735	47962	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48738,12 +47965,12 @@
48738	47965	state.addr = 819847183518878432LLU; // reporttype
48739	47966	break;
48740	47967	}
48741		- case 18446744073709548702LLU: // 99999999Rc'''''''''''''''
	47968	+ case 18446744073709548749LLU: // 99999999SM'''''''''''''''
48742	47969	{
48743		- state.addr = 18446744073709548703LLU; // 99999999Rd'''''''''''''''
	47970	+ state.addr = 18446744073709548750LLU; // 99999999SN'''''''''''''''
48744	47971	break;
48745	47972	}
48746		- case 18446744073709548703LLU: // 99999999Rd'''''''''''''''
	47973	+ case 18446744073709548750LLU: // 99999999SN'''''''''''''''
48747	47974	{
48748	47975	fprintf(stderr, "%s", " ");
48749	47976	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));

		@@ -48751,17 +47978,17 @@
48751	47978	fprintf(stderr, "%s\n", "");
48752	47979	exit(-1);
48753	47980	}
48754		- state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
	47981	+ state.addr = 18446744073709548751LLU; // 99999999SO'''''''''''''''
48755	47982	break;
48756	47983	}
48757		- case 18446744073709548704LLU: // 99999999Re'''''''''''''''
	47984	+ case 18446744073709548751LLU: // 99999999SO'''''''''''''''
48758	47985	{
48759	47986	heap.availilable_size_for_dynamic_objects += 0LLU;
48760	47987	heap.availilable_size_for_dynamic_objects += 0LLU;
48761		- state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
	47988	+ state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
48762	47989	break;
48763	47990	}
48764		- case 18446744073709548714LLU: // 99999999Ro'''''''''''''''
	47991	+ case 18446744073709548761LLU: // 99999999SY'''''''''''''''
48765	47992	{
48766	47993	// ACCUMULATE ARGUMENTS - BEGIN
48767	47994	{

		@@ -48781,7 +48008,7 @@
48781	48008	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48782	48009	}
48783	48010	// ACCUMULATE ARGUMENTS - END
48784		- uint64_t return_to = 18446744073709548699LLU;
	48011	+ uint64_t return_to = 18446744073709548746LLU;
48785	48012	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48786	48013	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48787	48014	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48790,17 +48017,17 @@
48790	48017	state.addr = 660220432971388961LLU; // initvarref
48791	48018	break;
48792	48019	}
48793		- case 18446744073709548699LLU: // 99999999R$'''''''''''''''
	48020	+ case 18446744073709548746LLU: // 99999999SJ'''''''''''''''
48794	48021	{
48795		- state.addr = 18446744073709548700LLU; // 99999999Ra'''''''''''''''
	48022	+ state.addr = 18446744073709548747LLU; // 99999999SK'''''''''''''''
48796	48023	break;
48797	48024	}
48798		- case 18446744073709548700LLU: // 99999999Ra'''''''''''''''
	48025	+ case 18446744073709548747LLU: // 99999999SK'''''''''''''''
48799	48026	{
48800		- state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
	48027	+ state.addr = 18446744073709548748LLU; // 99999999SL'''''''''''''''
48801	48028	break;
48802	48029	}
48803		- case 18446744073709548701LLU: // 99999999Rb'''''''''''''''
	48030	+ case 18446744073709548748LLU: // 99999999SL'''''''''''''''
48804	48031	{
48805	48032	// variable u64 parameter_ goes out of scope
48806	48033	// emitted destructur for type u64

		@@ -48808,10 +48035,10 @@
48808	48035	// variable u64 mutable___ goes out of scope
48809	48036	// emitted destructur for type u64
48810	48037	(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'''''''''''''''
48812	48039	break;
48813	48040	}
48814		- case 18446744073709548719LLU: // 99999999Rt'''''''''''''''
	48041	+ case 18446744073709548766LLU: // 99999999Sc'''''''''''''''
48815	48042	{
48816	48043	// ACCUMULATE ARGUMENTS - BEGIN
48817	48044	{

		@@ -48819,7 +48046,7 @@
48819	48046	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48820	48047	}
48821	48048	// ACCUMULATE ARGUMENTS - END
48822		- uint64_t return_to = 18446744073709548697LLU;
	48049	+ uint64_t return_to = 18446744073709548744LLU;
48823	48050	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48824	48051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48825	48052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48828,12 +48055,12 @@
48828	48055	state.addr = 839519719621918720LLU; // skipws____
48829	48056	break;
48830	48057	}
48831		- case 18446744073709548697LLU: // 99999999RY'''''''''''''''
	48058	+ case 18446744073709548744LLU: // 99999999SH'''''''''''''''
48832	48059	{
48833		- state.addr = 18446744073709548698LLU; // 99999999RZ'''''''''''''''
	48060	+ state.addr = 18446744073709548745LLU; // 99999999SI'''''''''''''''
48834	48061	break;
48835	48062	}
48836		- case 18446744073709548698LLU: // 99999999RZ'''''''''''''''
	48063	+ case 18446744073709548745LLU: // 99999999SI'''''''''''''''
48837	48064	{
48838	48065	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 8LLU)));
48839	48066	{

		@@ -48846,7 +48073,7 @@
48846	48073	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48847	48074	}
48848	48075	// ACCUMULATE ARGUMENTS - END
48849		- uint64_t return_to = 18446744073709548695LLU;
	48076	+ uint64_t return_to = 18446744073709548742LLU;
48850	48077	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48851	48078	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48852	48079	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48855,12 +48082,12 @@
48855	48082	state.addr = 839519719621918720LLU; // skipws____
48856	48083	break;
48857	48084	}
48858		- case 18446744073709548695LLU: // 99999999RW'''''''''''''''
	48085	+ case 18446744073709548742LLU: // 99999999SF'''''''''''''''
48859	48086	{
48860		- state.addr = 18446744073709548696LLU; // 99999999RX'''''''''''''''
	48087	+ state.addr = 18446744073709548743LLU; // 99999999SG'''''''''''''''
48861	48088	break;
48862	48089	}
48863		- case 18446744073709548696LLU: // 99999999RX'''''''''''''''
	48090	+ case 18446744073709548743LLU: // 99999999SG'''''''''''''''
48864	48091	{
48865	48092	{
48866	48093	uint64_t arg = 59LLU;

		@@ -48884,7 +48111,7 @@
48884	48111	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48885	48112	}
48886	48113	// ACCUMULATE ARGUMENTS - END
48887		- uint64_t return_to = 18446744073709548693LLU;
	48114	+ uint64_t return_to = 18446744073709548740LLU;
48888	48115	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
48889	48116	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48890	48117	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48893,17 +48120,17 @@
48893	48120	state.addr = 728666047794575267LLU; // matchoptch
48894	48121	break;
48895	48122	}
48896		- case 18446744073709548693LLU: // 99999999RU'''''''''''''''
	48123	+ case 18446744073709548740LLU: // 99999999SD'''''''''''''''
48897	48124	{
48898		- state.addr = 18446744073709548694LLU; // 99999999RV'''''''''''''''
	48125	+ state.addr = 18446744073709548741LLU; // 99999999SE'''''''''''''''
48899	48126	break;
48900	48127	}
48901		- case 18446744073709548694LLU: // 99999999RV'''''''''''''''
	48128	+ case 18446744073709548741LLU: // 99999999SE'''''''''''''''
48902	48129	{
48903		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548692LLU : 18446744073709548691LLU;
	48130	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548739LLU : 18446744073709548738LLU;
48904	48131	break;
48905	48132	}
48906		- case 18446744073709548692LLU: // 99999999RT'''''''''''''''
	48133	+ case 18446744073709548739LLU: // 99999999SC'''''''''''''''
48907	48134	{
48908	48135	// ACCUMULATE ARGUMENTS - BEGIN
48909	48136	{

		@@ -48915,7 +48142,7 @@
48915	48142	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48916	48143	}
48917	48144	// ACCUMULATE ARGUMENTS - END
48918		- uint64_t return_to = 18446744073709548689LLU;
	48145	+ uint64_t return_to = 18446744073709548736LLU;
48919	48146	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
48920	48147	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48921	48148	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48924,17 +48151,17 @@
48924	48151	state.addr = 517555565476695680LLU; // assertu64_
48925	48152	break;
48926	48153	}
48927		- case 18446744073709548689LLU: // 99999999RQ'''''''''''''''
	48154	+ case 18446744073709548736LLU: // 99999999S_'''''''''''''''
48928	48155	{
48929		- state.addr = 18446744073709548690LLU; // 99999999RR'''''''''''''''
	48156	+ state.addr = 18446744073709548737LLU; // 99999999SA'''''''''''''''
48930	48157	break;
48931	48158	}
48932		- case 18446744073709548690LLU: // 99999999RR'''''''''''''''
	48159	+ case 18446744073709548737LLU: // 99999999SA'''''''''''''''
48933	48160	{
48934		- state.addr = /initialize/*LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548688LLU : 18446744073709548687LLU;
	48161	+ state.addr = /initialize/*LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548735LLU : 18446744073709548734LLU;
48935	48162	break;
48936	48163	}
48937		- case 18446744073709548688LLU: // 99999999RP'''''''''''''''
	48164	+ case 18446744073709548735LLU: // 99999999R9'''''''''''''''
48938	48165	{
48939	48166	fprintf(stdout, "%s", "\n ");
48940	48167	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48959,7 +48186,7 @@
48959	48186	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48960	48187	}
48961	48188	// ACCUMULATE ARGUMENTS - END
48962		- uint64_t return_to = 18446744073709548685LLU;
	48189	+ uint64_t return_to = 18446744073709548732LLU;
48963	48190	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
48964	48191	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48965	48192	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48968,12 +48195,12 @@
48968	48195	state.addr = 587881357514113024LLU; // emitpar___
48969	48196	break;
48970	48197	}
48971		- case 18446744073709548685LLU: // 99999999RM'''''''''''''''
	48198	+ case 18446744073709548732LLU: // 99999999R6'''''''''''''''
48972	48199	{
48973		- state.addr = 18446744073709548686LLU; // 99999999RN'''''''''''''''
	48200	+ state.addr = 18446744073709548733LLU; // 99999999R7'''''''''''''''
48974	48201	break;
48975	48202	}
48976		- case 18446744073709548686LLU: // 99999999RN'''''''''''''''
	48203	+ case 18446744073709548733LLU: // 99999999R7'''''''''''''''
48977	48204	{
48978	48205	fprintf(stdout, "%s", " = 0;");
48979	48206	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48994,7 +48221,7 @@
48994	48221	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48995	48222	}
48996	48223	// ACCUMULATE ARGUMENTS - END
48997		- uint64_t return_to = 18446744073709548683LLU;
	48224	+ uint64_t return_to = 18446744073709548730LLU;
48998	48225	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48999	48226	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49000	48227	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49003,31 +48230,31 @@
49003	48230	state.addr = 732615645798520865LLU; // movevarref
49004	48231	break;
49005	48232	}
49006		- case 18446744073709548683LLU: // 99999999RK'''''''''''''''
	48233	+ case 18446744073709548730LLU: // 99999999R4'''''''''''''''
49007	48234	{
49008		- state.addr = 18446744073709548684LLU; // 99999999RL'''''''''''''''
	48235	+ state.addr = 18446744073709548731LLU; // 99999999R5'''''''''''''''
49009	48236	break;
49010	48237	}
49011		- case 18446744073709548684LLU: // 99999999RL'''''''''''''''
	48238	+ case 18446744073709548731LLU: // 99999999R5'''''''''''''''
49012	48239	{
49013	48240	heap.availilable_size_for_dynamic_objects += 0LLU;
49014	48241	heap.availilable_size_for_dynamic_objects += 0LLU;
49015		- state.addr = 18446744073709548682LLU; // 99999999RJ'''''''''''''''
	48242	+ state.addr = 18446744073709548729LLU; // 99999999R3'''''''''''''''
49016	48243	break;
49017	48244	}
49018		- case 18446744073709548687LLU: // 99999999RO'''''''''''''''
	48245	+ case 18446744073709548734LLU: // 99999999R8'''''''''''''''
49019	48246	{
49020		- state.addr = 18446744073709548682LLU; // 99999999RJ'''''''''''''''
	48247	+ state.addr = 18446744073709548729LLU; // 99999999R3'''''''''''''''
49021	48248	break;
49022	48249	}
49023		- case 18446744073709548682LLU: // 99999999RJ'''''''''''''''
	48250	+ case 18446744073709548729LLU: // 99999999R3'''''''''''''''
49024	48251	{
49025	48252	heap.availilable_size_for_dynamic_objects += 0LLU;
49026	48253	heap.availilable_size_for_dynamic_objects += 0LLU;
49027		- state.addr = 18446744073709548681LLU; // 99999999RI'''''''''''''''
	48254	+ state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
49028	48255	break;
49029	48256	}
49030		- case 18446744073709548691LLU: // 99999999RS'''''''''''''''
	48257	+ case 18446744073709548738LLU: // 99999999SB'''''''''''''''
49031	48258	{
49032	48259	// ACCUMULATE ARGUMENTS - BEGIN
49033	48260	{

		@@ -49039,7 +48266,7 @@
49039	48266	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49040	48267	}
49041	48268	// ACCUMULATE ARGUMENTS - END
49042		- uint64_t return_to = 18446744073709548679LLU;
	48269	+ uint64_t return_to = 18446744073709548726LLU;
49043	48270	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49044	48271	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49045	48272	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49048,22 +48275,22 @@
49048	48275	state.addr = 661605045736570880LLU; // isdigit___
49049	48276	break;
49050	48277	}
49051		- case 18446744073709548679LLU: // 99999999RG'''''''''''''''
	48278	+ case 18446744073709548726LLU: // 99999999R0'''''''''''''''
49052	48279	{
49053		- state.addr = 18446744073709548680LLU; // 99999999RH'''''''''''''''
	48280	+ state.addr = 18446744073709548727LLU; // 99999999R1'''''''''''''''
49054	48281	break;
49055	48282	}
49056		- case 18446744073709548680LLU: // 99999999RH'''''''''''''''
	48283	+ case 18446744073709548727LLU: // 99999999R1'''''''''''''''
49057	48284	{
49058		- state.addr = /nrconst___/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548678LLU : 18446744073709548677LLU;
	48285	+ state.addr = /nrconst___/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548725LLU : 18446744073709548724LLU;
49059	48286	break;
49060	48287	}
49061		- case 18446744073709548678LLU: // 99999999RF'''''''''''''''
	48288	+ case 18446744073709548725LLU: // 99999999Rz'''''''''''''''
49062	48289	{
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;
49064	48291	break;
49065	48292	}
49066		- case 18446744073709548676LLU: // 99999999RD'''''''''''''''
	48293	+ case 18446744073709548723LLU: // 99999999Rx'''''''''''''''
49067	48294	{
49068	48295	// ACCUMULATE ARGUMENTS - BEGIN
49069	48296	{

		@@ -49087,7 +48314,7 @@
49087	48314	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49088	48315	}
49089	48316	// ACCUMULATE ARGUMENTS - END
49090		- uint64_t return_to = 18446744073709548673LLU;
	48317	+ uint64_t return_to = 18446744073709548720LLU;
49091	48318	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
49092	48319	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49093	48320	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49096,12 +48323,12 @@
49096	48323	state.addr = 587881357514113024LLU; // emitpar___
49097	48324	break;
49098	48325	}
49099		- case 18446744073709548673LLU: // 99999999RA'''''''''''''''
	48326	+ case 18446744073709548720LLU: // 99999999Ru'''''''''''''''
49100	48327	{
49101		- state.addr = 18446744073709548674LLU; // 99999999RB'''''''''''''''
	48328	+ state.addr = 18446744073709548721LLU; // 99999999Rv'''''''''''''''
49102	48329	break;
49103	48330	}
49104		- case 18446744073709548674LLU: // 99999999RB'''''''''''''''
	48331	+ case 18446744073709548721LLU: // 99999999Rv'''''''''''''''
49105	48332	{
49106	48333	fprintf(stdout, "%s", " = ");
49107	48334	{

		@@ -49115,7 +48342,7 @@
49115	48342	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49116	48343	}
49117	48344	// ACCUMULATE ARGUMENTS - END
49118		- uint64_t return_to = 18446744073709548671LLU;
	48345	+ uint64_t return_to = 18446744073709548718LLU;
49119	48346	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49120	48347	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49121	48348	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49124,12 +48351,12 @@
49124	48351	state.addr = 787446708198178816LLU; // printnr___
49125	48352	break;
49126	48353	}
49127		- case 18446744073709548671LLU: // 99999999Q9'''''''''''''''
	48354	+ case 18446744073709548718LLU: // 99999999Rs'''''''''''''''
49128	48355	{
49129		- state.addr = 18446744073709548672LLU; // 99999999R_'''''''''''''''
	48356	+ state.addr = 18446744073709548719LLU; // 99999999Rt'''''''''''''''
49130	48357	break;
49131	48358	}
49132		- case 18446744073709548672LLU: // 99999999R_'''''''''''''''
	48359	+ case 18446744073709548719LLU: // 99999999Rt'''''''''''''''
49133	48360	{
49134	48361	fprintf(stdout, "%s", ";\n");
49135	48362	// variable u64 nr________ goes out of scope

		@@ -49137,10 +48364,10 @@
49137	48364	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 21
49138	48365	heap.availilable_size_for_dynamic_objects += 0LLU;
49139	48366	heap.availilable_size_for_dynamic_objects += 0LLU;
49140		- state.addr = 18446744073709548670LLU; // 99999999Q8'''''''''''''''
	48367	+ state.addr = 18446744073709548717LLU; // 99999999Rr'''''''''''''''
49141	48368	break;
49142	48369	}
49143		- case 18446744073709548675LLU: // 99999999RC'''''''''''''''
	48370	+ case 18446744073709548722LLU: // 99999999Rw'''''''''''''''
49144	48371	{
49145	48372	{
49146	48373	uint64_t arg = 0LLU;

		@@ -49147,10 +48374,10 @@
49147	48374	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
49148	48375	}
49149	48376	/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;
49151	48378	break;
49152	48379	}
49153		- case 18446744073709548669LLU: // 99999999Q7'''''''''''''''
	48380	+ case 18446744073709548716LLU: // 99999999Rq'''''''''''''''
49154	48381	{
49155	48382	// ACCUMULATE ARGUMENTS - BEGIN
49156	48383	{

		@@ -49162,7 +48389,7 @@
49162	48389	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49163	48390	}
49164	48391	// ACCUMULATE ARGUMENTS - END
49165		- uint64_t return_to = 18446744073709548666LLU;
	48392	+ uint64_t return_to = 18446744073709548713LLU;
49166	48393	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49167	48394	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49168	48395	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49171,22 +48398,22 @@
49171	48398	state.addr = 517555565476695680LLU; // assertu64_
49172	48399	break;
49173	48400	}
49174		- case 18446744073709548666LLU: // 99999999Q4'''''''''''''''
	48401	+ case 18446744073709548713LLU: // 99999999Rn'''''''''''''''
49175	48402	{
49176		- state.addr = 18446744073709548667LLU; // 99999999Q5'''''''''''''''
	48403	+ state.addr = 18446744073709548714LLU; // 99999999Ro'''''''''''''''
49177	48404	break;
49178	48405	}
49179		- case 18446744073709548667LLU: // 99999999Q5'''''''''''''''
	48406	+ case 18446744073709548714LLU: // 99999999Ro'''''''''''''''
49180	48407	{
49181		- state.addr = 18446744073709548668LLU; // 99999999Q6'''''''''''''''
	48408	+ state.addr = 18446744073709548715LLU; // 99999999Rp'''''''''''''''
49182	48409	break;
49183	48410	}
49184		- case 18446744073709548668LLU: // 99999999Q6'''''''''''''''
	48411	+ case 18446744073709548715LLU: // 99999999Rp'''''''''''''''
49185	48412	{
49186		- state.addr = /initialize/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709548665LLU : 18446744073709548664LLU;
	48413	+ state.addr = /initialize/*LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709548712LLU : 18446744073709548711LLU;
49187	48414	break;
49188	48415	}
49189		- case 18446744073709548665LLU: // 99999999Q3'''''''''''''''
	48416	+ case 18446744073709548712LLU: // 99999999Rm'''''''''''''''
49190	48417	{
49191	48418	// ACCUMULATE ARGUMENTS - BEGIN
49192	48419	{

		@@ -49206,7 +48433,7 @@
49206	48433	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49207	48434	}
49208	48435	// ACCUMULATE ARGUMENTS - END
49209		- uint64_t return_to = 18446744073709548662LLU;
	48436	+ uint64_t return_to = 18446744073709548709LLU;
49210	48437	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49211	48438	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49212	48439	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49215,44 +48442,44 @@
49215	48442	state.addr = 732615645798520865LLU; // movevarref
49216	48443	break;
49217	48444	}
49218		- case 18446744073709548662LLU: // 99999999Q0'''''''''''''''
	48445	+ case 18446744073709548709LLU: // 99999999Rj'''''''''''''''
49219	48446	{
49220		- state.addr = 18446744073709548663LLU; // 99999999Q1'''''''''''''''
	48447	+ state.addr = 18446744073709548710LLU; // 99999999Rk'''''''''''''''
49221	48448	break;
49222	48449	}
49223		- case 18446744073709548663LLU: // 99999999Q1'''''''''''''''
	48450	+ case 18446744073709548710LLU: // 99999999Rk'''''''''''''''
49224	48451	{
49225	48452	heap.availilable_size_for_dynamic_objects += 0LLU;
49226	48453	heap.availilable_size_for_dynamic_objects += 0LLU;
49227		- state.addr = 18446744073709548661LLU; // 99999999Qz'''''''''''''''
	48454	+ state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
49228	48455	break;
49229	48456	}
49230		- case 18446744073709548664LLU: // 99999999Q2'''''''''''''''
	48457	+ case 18446744073709548711LLU: // 99999999Rl'''''''''''''''
49231	48458	{
49232		- state.addr = 18446744073709548661LLU; // 99999999Qz'''''''''''''''
	48459	+ state.addr = 18446744073709548708LLU; // 99999999Ri'''''''''''''''
49233	48460	break;
49234	48461	}
49235		- case 18446744073709548661LLU: // 99999999Qz'''''''''''''''
	48462	+ case 18446744073709548708LLU: // 99999999Ri'''''''''''''''
49236	48463	{
49237	48464	// variable u64 nr________ goes out of scope
49238	48465	// emitted destructur for type u64
49239	48466	(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'''''''''''''''
49241	48468	break;
49242	48469	}
49243		- case 18446744073709548670LLU: // 99999999Q8'''''''''''''''
	48470	+ case 18446744073709548717LLU: // 99999999Rr'''''''''''''''
49244	48471	{
49245	48472	heap.availilable_size_for_dynamic_objects += 0LLU;
49246	48473	heap.availilable_size_for_dynamic_objects += 0LLU;
49247		- state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
	48474	+ state.addr = 18446744073709548707LLU; // 99999999Rh'''''''''''''''
49248	48475	break;
49249	48476	}
49250		- case 18446744073709548677LLU: // 99999999RE'''''''''''''''
	48477	+ case 18446744073709548724LLU: // 99999999Ry'''''''''''''''
49251	48478	{
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;
49253	48480	break;
49254	48481	}
49255		- case 18446744073709548659LLU: // 99999999Qx'''''''''''''''
	48482	+ case 18446744073709548706LLU: // 99999999Rg'''''''''''''''
49256	48483	{
49257	48484	// ACCUMULATE ARGUMENTS - BEGIN
49258	48485	{

		@@ -49260,7 +48487,7 @@
49260	48487	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49261	48488	}
49262	48489	// ACCUMULATE ARGUMENTS - END
49263		- uint64_t return_to = 18446744073709548656LLU;
	48490	+ uint64_t return_to = 18446744073709548703LLU;
49264	48491	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49265	48492	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49266	48493	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49269,12 +48496,12 @@
49269	48496	state.addr = 819847183515949359LLU; // reportinit
49270	48497	break;
49271	48498	}
49272		- case 18446744073709548656LLU: // 99999999Qu'''''''''''''''
	48499	+ case 18446744073709548703LLU: // 99999999Rd'''''''''''''''
49273	48500	{
49274		- state.addr = 18446744073709548657LLU; // 99999999Qv'''''''''''''''
	48501	+ state.addr = 18446744073709548704LLU; // 99999999Re'''''''''''''''
49275	48502	break;
49276	48503	}
49277		- case 18446744073709548657LLU: // 99999999Qv'''''''''''''''
	48504	+ case 18446744073709548704LLU: // 99999999Re'''''''''''''''
49278	48505	{
49279	48506	{
49280	48507	fprintf(stderr, "%s\n", "assignment to list not implemeted yet");

		@@ -49282,10 +48509,10 @@
49282	48509	}
49283	48510	heap.availilable_size_for_dynamic_objects += 0LLU;
49284	48511	heap.availilable_size_for_dynamic_objects += 0LLU;
49285		- state.addr = 18446744073709548655LLU; // 99999999Qt'''''''''''''''
	48512	+ state.addr = 18446744073709548702LLU; // 99999999Rc'''''''''''''''
49286	48513	break;
49287	48514	}
49288		- case 18446744073709548658LLU: // 99999999Qw'''''''''''''''
	48515	+ case 18446744073709548705LLU: // 99999999Rf'''''''''''''''
49289	48516	{
49290	48517	{
49291	48518	uint64_t arg = 0LLU;

		@@ -49297,7 +48524,7 @@
49297	48524	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49298	48525	}
49299	48526	// ACCUMULATE ARGUMENTS - END
49300		- uint64_t return_to = 18446744073709548653LLU;
	48527	+ uint64_t return_to = 18446744073709548700LLU;
49301	48528	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49302	48529	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49303	48530	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49306,12 +48533,12 @@
49306	48533	state.addr = 839519719621918720LLU; // skipws____
49307	48534	break;
49308	48535	}
49309		- case 18446744073709548653LLU: // 99999999Qr'''''''''''''''
	48536	+ case 18446744073709548700LLU: // 99999999Ra'''''''''''''''
49310	48537	{
49311		- state.addr = 18446744073709548654LLU; // 99999999Qs'''''''''''''''
	48538	+ state.addr = 18446744073709548701LLU; // 99999999Rb'''''''''''''''
49312	48539	break;
49313	48540	}
49314		- case 18446744073709548654LLU: // 99999999Qs'''''''''''''''
	48541	+ case 18446744073709548701LLU: // 99999999Rb'''''''''''''''
49315	48542	{
49316	48543	/srcid_____/LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 8LLU)));
49317	48544	{

		@@ -49336,7 +48563,7 @@
49336	48563	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49337	48564	}
49338	48565	// ACCUMULATE ARGUMENTS - END
49339		- uint64_t return_to = 18446744073709548651LLU;
	48566	+ uint64_t return_to = 18446744073709548698LLU;
49340	48567	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
49341	48568	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49342	48569	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49345,17 +48572,17 @@
49345	48572	state.addr = 728666047794575267LLU; // matchoptch
49346	48573	break;
49347	48574	}
49348		- case 18446744073709548651LLU: // 99999999Qp'''''''''''''''
	48575	+ case 18446744073709548698LLU: // 99999999RZ'''''''''''''''
49349	48576	{
49350		- state.addr = 18446744073709548652LLU; // 99999999Qq'''''''''''''''
	48577	+ state.addr = 18446744073709548699LLU; // 99999999R$'''''''''''''''
49351	48578	break;
49352	48579	}
49353		- case 18446744073709548652LLU: // 99999999Qq'''''''''''''''
	48580	+ case 18446744073709548699LLU: // 99999999R$'''''''''''''''
49354	48581	{
49355		- state.addr = /called____/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548650LLU : 18446744073709548649LLU;
	48582	+ state.addr = /called____/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548697LLU : 18446744073709548696LLU;
49356	48583	break;
49357	48584	}
49358		- case 18446744073709548650LLU: // 99999999Qo'''''''''''''''
	48585	+ case 18446744073709548697LLU: // 99999999RY'''''''''''''''
49359	48586	{
49360	48587	{
49361	48588	uint64_t arg = 0LLU;

		@@ -49413,7 +48640,7 @@
49413	48640	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49414	48641	}
49415	48642	// ACCUMULATE ARGUMENTS - END
49416		- uint64_t return_to = 18446744073709548647LLU;
	48643	+ uint64_t return_to = 18446744073709548694LLU;
49417	48644	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
49418	48645	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49419	48646	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49422,12 +48649,12 @@
49422	48649	state.addr = 54378275173643538LLU; // CALLCONSTR
49423	48650	break;
49424	48651	}
49425		- case 18446744073709548647LLU: // 99999999Ql'''''''''''''''
	48652	+ case 18446744073709548694LLU: // 99999999RV'''''''''''''''
49426	48653	{
49427		- state.addr = 18446744073709548648LLU; // 99999999Qm'''''''''''''''
	48654	+ state.addr = 18446744073709548695LLU; // 99999999RW'''''''''''''''
49428	48655	break;
49429	48656	}
49430		- case 18446744073709548648LLU: // 99999999Qm'''''''''''''''
	48657	+ case 18446744073709548695LLU: // 99999999RW'''''''''''''''
49431	48658	{
49432	48659	fprintf(stdout, "%s", ";\n ");
49433	48660	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -49452,7 +48679,7 @@
49452	48679	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49453	48680	}
49454	48681	// ACCUMULATE ARGUMENTS - END
49455		- uint64_t return_to = 18446744073709548645LLU;
	48682	+ uint64_t return_to = 18446744073709548692LLU;
49456	48683	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
49457	48684	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49458	48685	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49461,12 +48688,12 @@
49461	48688	state.addr = 587881357514113024LLU; // emitpar___
49462	48689	break;
49463	48690	}
49464		- case 18446744073709548645LLU: // 99999999Qj'''''''''''''''
	48691	+ case 18446744073709548692LLU: // 99999999RT'''''''''''''''
49465	48692	{
49466		- state.addr = 18446744073709548646LLU; // 99999999Qk'''''''''''''''
	48693	+ state.addr = 18446744073709548693LLU; // 99999999RU'''''''''''''''
49467	48694	break;
49468	48695	}
49469		- case 18446744073709548646LLU: // 99999999Qk'''''''''''''''
	48696	+ case 18446744073709548693LLU: // 99999999RU'''''''''''''''
49470	48697	{
49471	48698	fprintf(stdout, "%s", " = arg;");
49472	48699	fprintf(stdout, "%s", "\n }");

		@@ -49475,10 +48702,10 @@
49475	48702	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 24
49476	48703	heap.availilable_size_for_dynamic_objects += 0LLU;
49477	48704	heap.availilable_size_for_dynamic_objects += 0LLU;
49478		- state.addr = 18446744073709548644LLU; // 99999999Qi'''''''''''''''
	48705	+ state.addr = 18446744073709548691LLU; // 99999999RS'''''''''''''''
49479	48706	break;
49480	48707	}
49481		- case 18446744073709548649LLU: // 99999999Qn'''''''''''''''
	48708	+ case 18446744073709548696LLU: // 99999999RX'''''''''''''''
49482	48709	{
49483	48710	// ACCUMULATE ARGUMENTS - BEGIN
49484	48711	{

		@@ -49490,7 +48717,7 @@
49490	48717	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49491	48718	}
49492	48719	// ACCUMULATE ARGUMENTS - END
49493		- uint64_t return_to = 18446744073709548642LLU;
	48720	+ uint64_t return_to = 18446744073709548689LLU;
49494	48721	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49495	48722	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49496	48723	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49499,12 +48726,12 @@
49499	48726	state.addr = 517555565476695680LLU; // assertu64_
49500	48727	break;
49501	48728	}
49502		- case 18446744073709548642LLU: // 99999999Qg'''''''''''''''
	48729	+ case 18446744073709548689LLU: // 99999999RQ'''''''''''''''
49503	48730	{
49504		- state.addr = 18446744073709548643LLU; // 99999999Qh'''''''''''''''
	48731	+ state.addr = 18446744073709548690LLU; // 99999999RR'''''''''''''''
49505	48732	break;
49506	48733	}
49507		- case 18446744073709548643LLU: // 99999999Qh'''''''''''''''
	48734	+ case 18446744073709548690LLU: // 99999999RR'''''''''''''''
49508	48735	{
49509	48736	// ACCUMULATE ARGUMENTS - BEGIN
49510	48737	{

		@@ -49528,7 +48755,7 @@
49528	48755	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49529	48756	}
49530	48757	// ACCUMULATE ARGUMENTS - END
49531		- uint64_t return_to = 18446744073709548640LLU;
	48758	+ uint64_t return_to = 18446744073709548687LLU;
49532	48759	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
49533	48760	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49534	48761	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49537,12 +48764,12 @@
49537	48764	state.addr = 587881357514113024LLU; // emitpar___
49538	48765	break;
49539	48766	}
49540		- case 18446744073709548640LLU: // 99999999Qe'''''''''''''''
	48767	+ case 18446744073709548687LLU: // 99999999RO'''''''''''''''
49541	48768	{
49542		- state.addr = 18446744073709548641LLU; // 99999999Qf'''''''''''''''
	48769	+ state.addr = 18446744073709548688LLU; // 99999999RP'''''''''''''''
49543	48770	break;
49544	48771	}
49545		- case 18446744073709548641LLU: // 99999999Qf'''''''''''''''
	48772	+ case 18446744073709548688LLU: // 99999999RP'''''''''''''''
49546	48773	{
49547	48774	fprintf(stdout, "%s", " = ");
49548	48775	*LOCAL_ACCESS(heap.data, 23LLU, 14LLU) = 0LLU;

		@@ -49559,10 +48786,10 @@
49559	48786	};
49560	48787	*LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = arg;
49561	48788	}
49562		- state.addr = 18446744073709548639LLU; // 99999999Qd'''''''''''''''
	48789	+ state.addr = 18446744073709548686LLU; // 99999999RN'''''''''''''''
49563	48790	break;
49564	48791	}
49565		- case 18446744073709548639LLU: // 99999999Qd'''''''''''''''
	48792	+ case 18446744073709548686LLU: // 99999999RN'''''''''''''''
49566	48793	{
49567	48794	{
49568	48795	uint64_t arg = 0LLU;

		@@ -49636,7 +48863,7 @@
49636	48863	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49637	48864	}
49638	48865	// ACCUMULATE ARGUMENTS - END
49639		- uint64_t return_to = 18446744073709548637LLU;
	48866	+ uint64_t return_to = 18446744073709548684LLU;
49640	48867	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49641	48868	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49642	48869	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49645,12 +48872,12 @@
49645	48872	state.addr = 787472342492567585LLU; // procvarref
49646	48873	break;
49647	48874	}
49648		- case 18446744073709548637LLU: // 99999999Qb'''''''''''''''
	48875	+ case 18446744073709548684LLU: // 99999999RL'''''''''''''''
49649	48876	{
49650		- state.addr = 18446744073709548638LLU; // 99999999Qc'''''''''''''''
	48877	+ state.addr = 18446744073709548685LLU; // 99999999RM'''''''''''''''
49651	48878	break;
49652	48879	}
49653		- case 18446744073709548638LLU: // 99999999Qc'''''''''''''''
	48880	+ case 18446744073709548685LLU: // 99999999RM'''''''''''''''
49654	48881	{
49655	48882	// ACCUMULATE ARGUMENTS - BEGIN
49656	48883	{

		@@ -49670,7 +48897,7 @@
49670	48897	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49671	48898	}
49672	48899	// ACCUMULATE ARGUMENTS - END
49673		- uint64_t return_to = 18446744073709548635LLU;
	48900	+ uint64_t return_to = 18446744073709548682LLU;
49674	48901	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49675	48902	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49676	48903	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49679,12 +48906,12 @@
49679	48906	state.addr = 861504774606571689LLU; // typeassign
49680	48907	break;
49681	48908	}
49682		- case 18446744073709548635LLU: // 99999999Q$'''''''''''''''
	48909	+ case 18446744073709548682LLU: // 99999999RJ'''''''''''''''
49683	48910	{
49684		- state.addr = 18446744073709548636LLU; // 99999999Qa'''''''''''''''
	48911	+ state.addr = 18446744073709548683LLU; // 99999999RK'''''''''''''''
49685	48912	break;
49686	48913	}
49687		- case 18446744073709548636LLU: // 99999999Qa'''''''''''''''
	48914	+ case 18446744073709548683LLU: // 99999999RK'''''''''''''''
49688	48915	{
49689	48916	// variable u64 parameter_ goes out of scope
49690	48917	// emitted destructur for type u64

		@@ -49700,7 +48927,7 @@
49700	48927	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49701	48928	}
49702	48929	// ACCUMULATE ARGUMENTS - END
49703		- uint64_t return_to = 18446744073709548634LLU;
	48930	+ uint64_t return_to = 18446744073709548681LLU;
49704	48931	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49705	48932	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49706	48933	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49709,13 +48936,13 @@
49709	48936	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
49710	48937	break;
49711	48938	}
49712		- case 18446744073709548634LLU: // 99999999QZ'''''''''''''''
	48939	+ case 18446744073709548681LLU: // 99999999RI'''''''''''''''
49713	48940	{
49714	48941	(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'''''''''''''''
49716	48943	break;
49717	48944	}
49718		- case 18446744073709548644LLU: // 99999999Qi'''''''''''''''
	48945	+ case 18446744073709548691LLU: // 99999999RS'''''''''''''''
49719	48946	{
49720	48947	// variable u64 called____ goes out of scope
49721	48948	// emitted destructur for type u64

		@@ -49726,21 +48953,21 @@
49726	48953	// variable u64 srcid_____ goes out of scope
49727	48954	// emitted destructur for type u64
49728	48955	(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'''''''''''''''
49730	48957	break;
49731	48958	}
49732		- case 18446744073709548655LLU: // 99999999Qt'''''''''''''''
	48959	+ case 18446744073709548702LLU: // 99999999Rc'''''''''''''''
49733	48960	{
49734	48961	fprintf(stdout, "%s", ";\n");
49735		- state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
	48962	+ state.addr = 18446744073709548707LLU; // 99999999Rh'''''''''''''''
49736	48963	break;
49737	48964	}
49738		- case 18446744073709548660LLU: // 99999999Qy'''''''''''''''
	48965	+ case 18446744073709548707LLU: // 99999999Rh'''''''''''''''
49739	48966	{
49740		- state.addr = 18446744073709548681LLU; // 99999999RI'''''''''''''''
	48967	+ state.addr = 18446744073709548728LLU; // 99999999R2'''''''''''''''
49741	48968	break;
49742	48969	}
49743		- case 18446744073709548681LLU: // 99999999RI'''''''''''''''
	48970	+ case 18446744073709548728LLU: // 99999999R2'''''''''''''''
49744	48971	{
49745	48972	// variable u64 match_____ goes out of scope
49746	48973	// emitted destructur for type u64

		@@ -49768,7 +48995,7 @@
49768	48995	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49769	48996	}
49770	48997	// ACCUMULATE ARGUMENTS - END
49771		- uint64_t return_to = 18446744073709548633LLU;
	48998	+ uint64_t return_to = 18446744073709548680LLU;
49772	48999	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49773	49000	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49774	49001	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49777,7 +49004,7 @@
49777	49004	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
49778	49005	break;
49779	49006	}
49780		- case 18446744073709548633LLU: // 99999999QY'''''''''''''''
	49007	+ case 18446744073709548680LLU: // 99999999RH'''''''''''''''
49781	49008	{
49782	49009	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPEDST___ at 14
49783	49010	// parameter-reference u64 remainheap goes out of scope

		@@ -49826,7 +49053,7 @@
49826	49053	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49827	49054	}
49828	49055	// ACCUMULATE ARGUMENTS - END
49829		- uint64_t return_to = 18446744073709548631LLU;
	49056	+ uint64_t return_to = 18446744073709548678LLU;
49830	49057	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49831	49058	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49832	49059	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49835,12 +49062,12 @@
49835	49062	state.addr = 839519719621918720LLU; // skipws____
49836	49063	break;
49837	49064	}
49838		- case 18446744073709548631LLU: // 99999999QW'''''''''''''''
	49065	+ case 18446744073709548678LLU: // 99999999RF'''''''''''''''
49839	49066	{
49840		- state.addr = 18446744073709548632LLU; // 99999999QX'''''''''''''''
	49067	+ state.addr = 18446744073709548679LLU; // 99999999RG'''''''''''''''
49841	49068	break;
49842	49069	}
49843		- case 18446744073709548632LLU: // 99999999QX'''''''''''''''
	49070	+ case 18446744073709548679LLU: // 99999999RG'''''''''''''''
49844	49071	{
49845	49072	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 5LLU)));
49846	49073	fprintf(stdout, "%s", "\n list_reverse(heap.data, &");

		@@ -49850,7 +49077,7 @@
49850	49077	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49851	49078	}
49852	49079	// ACCUMULATE ARGUMENTS - END
49853		- uint64_t return_to = 18446744073709548629LLU;
	49080	+ uint64_t return_to = 18446744073709548676LLU;
49854	49081	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49855	49082	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49856	49083	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49859,12 +49086,12 @@
49859	49086	state.addr = 839519719621918720LLU; // skipws____
49860	49087	break;
49861	49088	}
49862		- case 18446744073709548629LLU: // 99999999QU'''''''''''''''
	49089	+ case 18446744073709548676LLU: // 99999999RD'''''''''''''''
49863	49090	{
49864		- state.addr = 18446744073709548630LLU; // 99999999QV'''''''''''''''
	49091	+ state.addr = 18446744073709548677LLU; // 99999999RE'''''''''''''''
49865	49092	break;
49866	49093	}
49867		- case 18446744073709548630LLU: // 99999999QV'''''''''''''''
	49094	+ case 18446744073709548677LLU: // 99999999RE'''''''''''''''
49868	49095	{
49869	49096	{
49870	49097	uint64_t arg = 0LLU;

		@@ -49882,10 +49109,10 @@
49882	49109	};
49883	49110	*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = arg;
49884	49111	}
49885		- state.addr = 18446744073709548628LLU; // 99999999QT'''''''''''''''
	49112	+ state.addr = 18446744073709548675LLU; // 99999999RC'''''''''''''''
49886	49113	break;
49887	49114	}
49888		- case 18446744073709548628LLU: // 99999999QT'''''''''''''''
	49115	+ case 18446744073709548675LLU: // 99999999RC'''''''''''''''
49889	49116	{
49890	49117	{
49891	49118	uint64_t arg = 0LLU;

		@@ -49897,7 +49124,7 @@
49897	49124	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49898	49125	}
49899	49126	// ACCUMULATE ARGUMENTS - END
49900		- uint64_t return_to = 18446744073709548625LLU;
	49127	+ uint64_t return_to = 18446744073709548672LLU;
49901	49128	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49902	49129	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49903	49130	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49906,12 +49133,12 @@
49906	49133	state.addr = 839519719621918720LLU; // skipws____
49907	49134	break;
49908	49135	}
49909		- case 18446744073709548625LLU: // 99999999QQ'''''''''''''''
	49136	+ case 18446744073709548672LLU: // 99999999R_'''''''''''''''
49910	49137	{
49911		- state.addr = 18446744073709548626LLU; // 99999999QR'''''''''''''''
	49138	+ state.addr = 18446744073709548673LLU; // 99999999RA'''''''''''''''
49912	49139	break;
49913	49140	}
49914		- case 18446744073709548626LLU: // 99999999QR'''''''''''''''
	49141	+ case 18446744073709548673LLU: // 99999999RA'''''''''''''''
49915	49142	{
49916	49143	/id________/LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
49917	49144	{

		@@ -49988,7 +49215,7 @@
49988	49215	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49989	49216	}
49990	49217	// ACCUMULATE ARGUMENTS - END
49991		- uint64_t return_to = 18446744073709548623LLU;
	49218	+ uint64_t return_to = 18446744073709548670LLU;
49992	49219	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49993	49220	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49994	49221	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49997,12 +49224,12 @@
49997	49224	state.addr = 787472342492567585LLU; // procvarref
49998	49225	break;
49999	49226	}
50000		- case 18446744073709548623LLU: // 99999999QO'''''''''''''''
	49227	+ case 18446744073709548670LLU: // 99999999Q8'''''''''''''''
50001	49228	{
50002		- state.addr = 18446744073709548624LLU; // 99999999QP'''''''''''''''
	49229	+ state.addr = 18446744073709548671LLU; // 99999999Q9'''''''''''''''
50003	49230	break;
50004	49231	}
50005		- case 18446744073709548624LLU: // 99999999QP'''''''''''''''
	49232	+ case 18446744073709548671LLU: // 99999999Q9'''''''''''''''
50006	49233	{
50007	49234	{
50008	49235	uint64_t arg = 0LLU;

		@@ -50034,7 +49261,7 @@
50034	49261	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50035	49262	}
50036	49263	// ACCUMULATE ARGUMENTS - END
50037		- uint64_t return_to = 18446744073709548621LLU;
	49264	+ uint64_t return_to = 18446744073709548668LLU;
50038	49265	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
50039	49266	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50040	49267	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50043,12 +49270,12 @@
50043	49270	state.addr = 734295421765213120LLU; // mutassert_
50044	49271	break;
50045	49272	}
50046		- case 18446744073709548621LLU: // 99999999QM'''''''''''''''
	49273	+ case 18446744073709548668LLU: // 99999999Q6'''''''''''''''
50047	49274	{
50048		- state.addr = 18446744073709548622LLU; // 99999999QN'''''''''''''''
	49275	+ state.addr = 18446744073709548669LLU; // 99999999Q7'''''''''''''''
50049	49276	break;
50050	49277	}
50051		- case 18446744073709548622LLU: // 99999999QN'''''''''''''''
	49278	+ case 18446744073709548669LLU: // 99999999Q7'''''''''''''''
50052	49279	{
50053	49280	// variable u64 name______ goes out of scope
50054	49281	// emitted destructur for type u64

		@@ -50065,10 +49292,10 @@
50065	49292	// variable u64 parameter_ goes out of scope
50066	49293	// emitted destructur for type u64
50067	49294	(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'''''''''''''''
50069	49296	break;
50070	49297	}
50071		- case 18446744073709548627LLU: // 99999999QS'''''''''''''''
	49298	+ case 18446744073709548674LLU: // 99999999RB'''''''''''''''
50072	49299	{
50073	49300	// ACCUMULATE ARGUMENTS - BEGIN
50074	49301	{

		@@ -50080,7 +49307,7 @@
50080	49307	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50081	49308	}
50082	49309	// ACCUMULATE ARGUMENTS - END
50083		- uint64_t return_to = 18446744073709548619LLU;
	49310	+ uint64_t return_to = 18446744073709548666LLU;
50084	49311	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50085	49312	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50086	49313	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50089,12 +49316,12 @@
50089	49316	state.addr = 517555565474237359LLU; // assertlist
50090	49317	break;
50091	49318	}
50092		- case 18446744073709548619LLU: // 99999999QK'''''''''''''''
	49319	+ case 18446744073709548666LLU: // 99999999Q4'''''''''''''''
50093	49320	{
50094		- state.addr = 18446744073709548620LLU; // 99999999QL'''''''''''''''
	49321	+ state.addr = 18446744073709548667LLU; // 99999999Q5'''''''''''''''
50095	49322	break;
50096	49323	}
50097		- case 18446744073709548620LLU: // 99999999QL'''''''''''''''
	49324	+ case 18446744073709548667LLU: // 99999999Q5'''''''''''''''
50098	49325	{
50099	49326	fprintf(stdout, "%s", ");");
50100	49327	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -50103,7 +49330,7 @@
50103	49330	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50104	49331	}
50105	49332	// ACCUMULATE ARGUMENTS - END
50106		- uint64_t return_to = 18446744073709548617LLU;
	49333	+ uint64_t return_to = 18446744073709548664LLU;
50107	49334	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50108	49335	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50109	49336	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50112,12 +49339,12 @@
50112	49339	state.addr = 839519719621918720LLU; // skipws____
50113	49340	break;
50114	49341	}
50115		- case 18446744073709548617LLU: // 99999999QI'''''''''''''''
	49342	+ case 18446744073709548664LLU: // 99999999Q2'''''''''''''''
50116	49343	{
50117		- state.addr = 18446744073709548618LLU; // 99999999QJ'''''''''''''''
	49344	+ state.addr = 18446744073709548665LLU; // 99999999Q3'''''''''''''''
50118	49345	break;
50119	49346	}
50120		- case 18446744073709548618LLU: // 99999999QJ'''''''''''''''
	49347	+ case 18446744073709548665LLU: // 99999999Q3'''''''''''''''
50121	49348	{
50122	49349	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 13LLU, 5LLU)), stdin);
50123	49350	if(')' != (char)getchar())

		@@ -50136,7 +49363,7 @@
50136	49363	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50137	49364	}
50138	49365	// ACCUMULATE ARGUMENTS - END
50139		- uint64_t return_to = 18446744073709548616LLU;
	49366	+ uint64_t return_to = 18446744073709548663LLU;
50140	49367	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50141	49368	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50142	49369	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50145,7 +49372,7 @@
50145	49372	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
50146	49373	break;
50147	49374	}
50148		- case 18446744073709548616LLU: // 99999999QH'''''''''''''''
	49375	+ case 18446744073709548663LLU: // 99999999Q1'''''''''''''''
50149	49376	{
50150	49377	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 12
50151	49378	// variable u64 id________ goes out of scope

		@@ -50192,7 +49419,7 @@
50192	49419	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50193	49420	}
50194	49421	// ACCUMULATE ARGUMENTS - END
50195		- uint64_t return_to = 18446744073709548614LLU;
	49422	+ uint64_t return_to = 18446744073709548661LLU;
50196	49423	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50197	49424	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50198	49425	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50201,12 +49428,12 @@
50201	49428	state.addr = 839519719621918720LLU; // skipws____
50202	49429	break;
50203	49430	}
50204		- case 18446744073709548614LLU: // 99999999QF'''''''''''''''
	49431	+ case 18446744073709548661LLU: // 99999999Qz'''''''''''''''
50205	49432	{
50206		- state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
	49433	+ state.addr = 18446744073709548662LLU; // 99999999Q0'''''''''''''''
50207	49434	break;
50208	49435	}
50209		- case 18446744073709548615LLU: // 99999999QG'''''''''''''''
	49436	+ case 18446744073709548662LLU: // 99999999Q0'''''''''''''''
50210	49437	{
50211	49438	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 5LLU)));
50212	49439	fprintf(stdout, "%s", "\n list_size(heap.data, ");

		@@ -50216,7 +49443,7 @@
50216	49443	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50217	49444	}
50218	49445	// ACCUMULATE ARGUMENTS - END
50219		- uint64_t return_to = 18446744073709548612LLU;
	49446	+ uint64_t return_to = 18446744073709548659LLU;
50220	49447	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50221	49448	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50222	49449	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50225,12 +49452,12 @@
50225	49452	state.addr = 839519719621918720LLU; // skipws____
50226	49453	break;
50227	49454	}
50228		- case 18446744073709548612LLU: // 99999999QD'''''''''''''''
	49455	+ case 18446744073709548659LLU: // 99999999Qx'''''''''''''''
50229	49456	{
50230		- state.addr = 18446744073709548613LLU; // 99999999QE'''''''''''''''
	49457	+ state.addr = 18446744073709548660LLU; // 99999999Qy'''''''''''''''
50231	49458	break;
50232	49459	}
50233		- case 18446744073709548613LLU: // 99999999QE'''''''''''''''
	49460	+ case 18446744073709548660LLU: // 99999999Qy'''''''''''''''
50234	49461	{
50235	49462	{
50236	49463	uint64_t arg = 0LLU;

		@@ -50248,10 +49475,10 @@
50248	49475	};
50249	49476	*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = arg;
50250	49477	}
50251		- state.addr = 18446744073709548611LLU; // 99999999QC'''''''''''''''
	49478	+ state.addr = 18446744073709548658LLU; // 99999999Qw'''''''''''''''
50252	49479	break;
50253	49480	}
50254		- case 18446744073709548611LLU: // 99999999QC'''''''''''''''
	49481	+ case 18446744073709548658LLU: // 99999999Qw'''''''''''''''
50255	49482	{
50256	49483	{
50257	49484	uint64_t arg = 0LLU;

		@@ -50263,7 +49490,7 @@
50263	49490	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50264	49491	}
50265	49492	// ACCUMULATE ARGUMENTS - END
50266		- uint64_t return_to = 18446744073709548608LLU;
	49493	+ uint64_t return_to = 18446744073709548655LLU;
50267	49494	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50268	49495	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50269	49496	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50272,12 +49499,12 @@
50272	49499	state.addr = 839519719621918720LLU; // skipws____
50273	49500	break;
50274	49501	}
50275		- case 18446744073709548608LLU: // 99999999Q_'''''''''''''''
	49502	+ case 18446744073709548655LLU: // 99999999Qt'''''''''''''''
50276	49503	{
50277		- state.addr = 18446744073709548609LLU; // 99999999QA'''''''''''''''
	49504	+ state.addr = 18446744073709548656LLU; // 99999999Qu'''''''''''''''
50278	49505	break;
50279	49506	}
50280		- case 18446744073709548609LLU: // 99999999QA'''''''''''''''
	49507	+ case 18446744073709548656LLU: // 99999999Qu'''''''''''''''
50281	49508	{
50282	49509	/id0_______/LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
50283	49510	{

		@@ -50354,7 +49581,7 @@
50354	49581	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50355	49582	}
50356	49583	// ACCUMULATE ARGUMENTS - END
50357		- uint64_t return_to = 18446744073709548606LLU;
	49584	+ uint64_t return_to = 18446744073709548653LLU;
50358	49585	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
50359	49586	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50360	49587	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50363,12 +49590,12 @@
50363	49590	state.addr = 787472342492567585LLU; // procvarref
50364	49591	break;
50365	49592	}
50366		- case 18446744073709548606LLU: // 99999999P8'''''''''''''''
	49593	+ case 18446744073709548653LLU: // 99999999Qr'''''''''''''''
50367	49594	{
50368		- state.addr = 18446744073709548607LLU; // 99999999P9'''''''''''''''
	49595	+ state.addr = 18446744073709548654LLU; // 99999999Qs'''''''''''''''
50369	49596	break;
50370	49597	}
50371		- case 18446744073709548607LLU: // 99999999P9'''''''''''''''
	49598	+ case 18446744073709548654LLU: // 99999999Qs'''''''''''''''
50372	49599	{
50373	49600	// variable u64 idx_______ goes out of scope
50374	49601	// emitted destructur for type u64

		@@ -50379,10 +49606,10 @@
50379	49606	// variable u64 parameter_ goes out of scope
50380	49607	// emitted destructur for type u64
50381	49608	(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'''''''''''''''
50383	49610	break;
50384	49611	}
50385		- case 18446744073709548610LLU: // 99999999QB'''''''''''''''
	49612	+ case 18446744073709548657LLU: // 99999999Qv'''''''''''''''
50386	49613	{
50387	49614	// ACCUMULATE ARGUMENTS - BEGIN
50388	49615	{

		@@ -50394,7 +49621,7 @@
50394	49621	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50395	49622	}
50396	49623	// ACCUMULATE ARGUMENTS - END
50397		- uint64_t return_to = 18446744073709548604LLU;
	49624	+ uint64_t return_to = 18446744073709548651LLU;
50398	49625	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50399	49626	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50400	49627	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50403,12 +49630,12 @@
50403	49630	state.addr = 517555565474237359LLU; // assertlist
50404	49631	break;
50405	49632	}
50406		- case 18446744073709548604LLU: // 99999999P6'''''''''''''''
	49633	+ case 18446744073709548651LLU: // 99999999Qp'''''''''''''''
50407	49634	{
50408		- state.addr = 18446744073709548605LLU; // 99999999P7'''''''''''''''
	49635	+ state.addr = 18446744073709548652LLU; // 99999999Qq'''''''''''''''
50409	49636	break;
50410	49637	}
50411		- case 18446744073709548605LLU: // 99999999P7'''''''''''''''
	49638	+ case 18446744073709548652LLU: // 99999999Qq'''''''''''''''
50412	49639	{
50413	49640	fprintf(stdout, "%s", ", &");
50414	49641	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -50417,7 +49644,7 @@
50417	49644	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50418	49645	}
50419	49646	// ACCUMULATE ARGUMENTS - END
50420		- uint64_t return_to = 18446744073709548601LLU;
	49647	+ uint64_t return_to = 18446744073709548648LLU;
50421	49648	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50422	49649	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50423	49650	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50426,18 +49653,18 @@
50426	49653	state.addr = 839519719621918720LLU; // skipws____
50427	49654	break;
50428	49655	}
50429		- case 18446744073709548601LLU: // 99999999P3'''''''''''''''
	49656	+ case 18446744073709548648LLU: // 99999999Qm'''''''''''''''
50430	49657	{
50431		- state.addr = 18446744073709548602LLU; // 99999999P4'''''''''''''''
	49658	+ state.addr = 18446744073709548649LLU; // 99999999Qn'''''''''''''''
50432	49659	break;
50433	49660	}
50434		- case 18446744073709548602LLU: // 99999999P4'''''''''''''''
	49661	+ case 18446744073709548649LLU: // 99999999Qn'''''''''''''''
50435	49662	{
50436	49663	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
50437		- state.addr = 18446744073709548603LLU; // 99999999P5'''''''''''''''
	49664	+ state.addr = 18446744073709548650LLU; // 99999999Qo'''''''''''''''
50438	49665	break;
50439	49666	}
50440		- case 18446744073709548603LLU: // 99999999P5'''''''''''''''
	49667	+ case 18446744073709548650LLU: // 99999999Qo'''''''''''''''
50441	49668	{
50442	49669	// ACCUMULATE ARGUMENTS - BEGIN
50443	49670	{

		@@ -50445,7 +49672,7 @@
50445	49672	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50446	49673	}
50447	49674	// ACCUMULATE ARGUMENTS - END
50448		- uint64_t return_to = 18446744073709548599LLU;
	49675	+ uint64_t return_to = 18446744073709548646LLU;
50449	49676	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50450	49677	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50451	49678	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50454,12 +49681,12 @@
50454	49681	state.addr = 839519719621918720LLU; // skipws____
50455	49682	break;
50456	49683	}
50457		- case 18446744073709548599LLU: // 99999999P1'''''''''''''''
	49684	+ case 18446744073709548646LLU: // 99999999Qk'''''''''''''''
50458	49685	{
50459		- state.addr = 18446744073709548600LLU; // 99999999P2'''''''''''''''
	49686	+ state.addr = 18446744073709548647LLU; // 99999999Ql'''''''''''''''
50460	49687	break;
50461	49688	}
50462		- case 18446744073709548600LLU: // 99999999P2'''''''''''''''
	49689	+ case 18446744073709548647LLU: // 99999999Ql'''''''''''''''
50463	49690	{
50464	49691	{
50465	49692	uint64_t arg = 0;

		@@ -50473,10 +49700,10 @@
50473	49700	};
50474	49701	*LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = arg;
50475	49702	}
50476		- state.addr = 18446744073709548598LLU; // 99999999P0'''''''''''''''
	49703	+ state.addr = 18446744073709548645LLU; // 99999999Qj'''''''''''''''
50477	49704	break;
50478	49705	}
50479		- case 18446744073709548598LLU: // 99999999P0'''''''''''''''
	49706	+ case 18446744073709548645LLU: // 99999999Qj'''''''''''''''
50480	49707	{
50481	49708	{
50482	49709	uint64_t arg = 0LLU;

		@@ -50488,7 +49715,7 @@
50488	49715	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50489	49716	}
50490	49717	// ACCUMULATE ARGUMENTS - END
50491		- uint64_t return_to = 18446744073709548595LLU;
	49718	+ uint64_t return_to = 18446744073709548642LLU;
50492	49719	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50493	49720	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50494	49721	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50497,12 +49724,12 @@
50497	49724	state.addr = 839519719621918720LLU; // skipws____
50498	49725	break;
50499	49726	}
50500		- case 18446744073709548595LLU: // 99999999Px'''''''''''''''
	49727	+ case 18446744073709548642LLU: // 99999999Qg'''''''''''''''
50501	49728	{
50502		- state.addr = 18446744073709548596LLU; // 99999999Py'''''''''''''''
	49729	+ state.addr = 18446744073709548643LLU; // 99999999Qh'''''''''''''''
50503	49730	break;
50504	49731	}
50505		- case 18446744073709548596LLU: // 99999999Py'''''''''''''''
	49732	+ case 18446744073709548643LLU: // 99999999Qh'''''''''''''''
50506	49733	{
50507	49734	/id1_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 5LLU)));
50508	49735	{

		@@ -50587,7 +49814,7 @@
50587	49814	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50588	49815	}
50589	49816	// ACCUMULATE ARGUMENTS - END
50590		- uint64_t return_to = 18446744073709548593LLU;
	49817	+ uint64_t return_to = 18446744073709548640LLU;
50591	49818	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
50592	49819	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50593	49820	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50596,12 +49823,12 @@
50596	49823	state.addr = 787472342492567585LLU; // procvarref
50597	49824	break;
50598	49825	}
50599		- case 18446744073709548593LLU: // 99999999Pv'''''''''''''''
	49826	+ case 18446744073709548640LLU: // 99999999Qe'''''''''''''''
50600	49827	{
50601		- state.addr = 18446744073709548594LLU; // 99999999Pw'''''''''''''''
	49828	+ state.addr = 18446744073709548641LLU; // 99999999Qf'''''''''''''''
50602	49829	break;
50603	49830	}
50604		- case 18446744073709548594LLU: // 99999999Pw'''''''''''''''
	49831	+ case 18446744073709548641LLU: // 99999999Qf'''''''''''''''
50605	49832	{
50606	49833	// ACCUMULATE ARGUMENTS - BEGIN
50607	49834	{

		@@ -50613,7 +49840,7 @@
50613	49840	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50614	49841	}
50615	49842	// ACCUMULATE ARGUMENTS - END
50616		- uint64_t return_to = 18446744073709548591LLU;
	49843	+ uint64_t return_to = 18446744073709548638LLU;
50617	49844	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50618	49845	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50619	49846	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50622,12 +49849,12 @@
50622	49849	state.addr = 517555565476695680LLU; // assertu64_
50623	49850	break;
50624	49851	}
50625		- case 18446744073709548591LLU: // 99999999Pt'''''''''''''''
	49852	+ case 18446744073709548638LLU: // 99999999Qc'''''''''''''''
50626	49853	{
50627		- state.addr = 18446744073709548592LLU; // 99999999Pu'''''''''''''''
	49854	+ state.addr = 18446744073709548639LLU; // 99999999Qd'''''''''''''''
50628	49855	break;
50629	49856	}
50630		- case 18446744073709548592LLU: // 99999999Pu'''''''''''''''
	49857	+ case 18446744073709548639LLU: // 99999999Qd'''''''''''''''
50631	49858	{
50632	49859	{
50633	49860	uint64_t arg = 2LLU;

		@@ -50655,7 +49882,7 @@
50655	49882	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50656	49883	}
50657	49884	// ACCUMULATE ARGUMENTS - END
50658		- uint64_t return_to = 18446744073709548589LLU;
	49885	+ uint64_t return_to = 18446744073709548636LLU;
50659	49886	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
50660	49887	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50661	49888	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50664,12 +49891,12 @@
50664	49891	state.addr = 734295421765213120LLU; // mutassert_
50665	49892	break;
50666	49893	}
50667		- case 18446744073709548589LLU: // 99999999Pr'''''''''''''''
	49894	+ case 18446744073709548636LLU: // 99999999Qa'''''''''''''''
50668	49895	{
50669		- state.addr = 18446744073709548590LLU; // 99999999Ps'''''''''''''''
	49896	+ state.addr = 18446744073709548637LLU; // 99999999Qb'''''''''''''''
50670	49897	break;
50671	49898	}
50672		- case 18446744073709548590LLU: // 99999999Ps'''''''''''''''
	49899	+ case 18446744073709548637LLU: // 99999999Qb'''''''''''''''
50673	49900	{
50674	49901	// variable u64 parnr_____ goes out of scope
50675	49902	// emitted destructur for type u64

		@@ -50692,10 +49919,10 @@
50692	49919	// variable u64 id1_______ goes out of scope
50693	49920	// emitted destructur for type u64
50694	49921	(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'''''''''''''''
50696	49923	break;
50697	49924	}
50698		- case 18446744073709548597LLU: // 99999999Pz'''''''''''''''
	49925	+ case 18446744073709548644LLU: // 99999999Qi'''''''''''''''
50699	49926	{
50700	49927	fprintf(stdout, "%s", ");");
50701	49928	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -50704,7 +49931,7 @@
50704	49931	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50705	49932	}
50706	49933	// ACCUMULATE ARGUMENTS - END
50707		- uint64_t return_to = 18446744073709548587LLU;
	49934	+ uint64_t return_to = 18446744073709548634LLU;
50708	49935	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50709	49936	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50710	49937	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50713,12 +49940,12 @@
50713	49940	state.addr = 839519719621918720LLU; // skipws____
50714	49941	break;
50715	49942	}
50716		- case 18446744073709548587LLU: // 99999999Pp'''''''''''''''
	49943	+ case 18446744073709548634LLU: // 99999999QZ'''''''''''''''
50717	49944	{
50718		- state.addr = 18446744073709548588LLU; // 99999999Pq'''''''''''''''
	49945	+ state.addr = 18446744073709548635LLU; // 99999999Q$'''''''''''''''
50719	49946	break;
50720	49947	}
50721		- case 18446744073709548588LLU: // 99999999Pq'''''''''''''''
	49948	+ case 18446744073709548635LLU: // 99999999Q$'''''''''''''''
50722	49949	{
50723	49950	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 14LLU, 5LLU)), stdin);
50724	49951	if(')' != (char)getchar())

		@@ -50734,7 +49961,7 @@
50734	49961	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50735	49962	}
50736	49963	// ACCUMULATE ARGUMENTS - END
50737		- uint64_t return_to = 18446744073709548586LLU;
	49964	+ uint64_t return_to = 18446744073709548633LLU;
50738	49965	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50739	49966	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50740	49967	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50743,7 +49970,7 @@
50743	49970	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
50744	49971	break;
50745	49972	}
50746		- case 18446744073709548586LLU: // 99999999Po'''''''''''''''
	49973	+ case 18446744073709548633LLU: // 99999999QY'''''''''''''''
50747	49974	{
50748	49975	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type1_____ at 14
50749	49976	// variable u64 mutable0__ goes out of scope

		@@ -50757,7 +49984,7 @@
50757	49984	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50758	49985	}
50759	49986	// ACCUMULATE ARGUMENTS - END
50760		- uint64_t return_to = 18446744073709548585LLU;
	49987	+ uint64_t return_to = 18446744073709548632LLU;
50761	49988	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50762	49989	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50763	49990	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50766,7 +49993,7 @@
50766	49993	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
50767	49994	break;
50768	49995	}
50769		- case 18446744073709548585LLU: // 99999999Pn'''''''''''''''
	49996	+ case 18446744073709548632LLU: // 99999999QX'''''''''''''''
50770	49997	{
50771	49998	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type0_____ at 12
50772	49999	// variable u64 id0_______ goes out of scope

		@@ -50817,7 +50044,7 @@
50817	50044	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50818	50045	}
50819	50046	// ACCUMULATE ARGUMENTS - END
50820		- uint64_t return_to = 18446744073709548583LLU;
	50047	+ uint64_t return_to = 18446744073709548630LLU;
50821	50048	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50822	50049	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50823	50050	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50826,12 +50053,12 @@
50826	50053	state.addr = 517555828430075934LLU; // assign_dec
50827	50054	break;
50828	50055	}
50829		- case 18446744073709548583LLU: // 99999999Pl'''''''''''''''
	50056	+ case 18446744073709548630LLU: // 99999999QV'''''''''''''''
50830	50057	{
50831		- state.addr = 18446744073709548584LLU; // 99999999Pm'''''''''''''''
	50058	+ state.addr = 18446744073709548631LLU; // 99999999QW'''''''''''''''
50832	50059	break;
50833	50060	}
50834		- case 18446744073709548584LLU: // 99999999Pm'''''''''''''''
	50061	+ case 18446744073709548631LLU: // 99999999QW'''''''''''''''
50835	50062	{
50836	50063	{
50837	50064	uint64_t arg = 0LLU;

		@@ -50847,7 +50074,7 @@
50847	50074	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50848	50075	}
50849	50076	// ACCUMULATE ARGUMENTS - END
50850		- uint64_t return_to = 18446744073709548581LLU;
	50077	+ uint64_t return_to = 18446744073709548628LLU;
50851	50078	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50852	50079	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50853	50080	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50856,12 +50083,12 @@
50856	50083	state.addr = 517555828430075934LLU; // assign_dec
50857	50084	break;
50858	50085	}
50859		- case 18446744073709548581LLU: // 99999999Pj'''''''''''''''
	50086	+ case 18446744073709548628LLU: // 99999999QT'''''''''''''''
50860	50087	{
50861		- state.addr = 18446744073709548582LLU; // 99999999Pk'''''''''''''''
	50088	+ state.addr = 18446744073709548629LLU; // 99999999QU'''''''''''''''
50862	50089	break;
50863	50090	}
50864		- case 18446744073709548582LLU: // 99999999Pk'''''''''''''''
	50091	+ case 18446744073709548629LLU: // 99999999QU'''''''''''''''
50865	50092	{
50866	50093	{
50867	50094	uint64_t arg = 0LLU;

		@@ -50887,10 +50114,10 @@
50887	50114	};
50888	50115	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = arg;
50889	50116	}
50890		- state.addr = 18446744073709548580LLU; // 99999999Pi'''''''''''''''
	50117	+ state.addr = 18446744073709548627LLU; // 99999999QS'''''''''''''''
50891	50118	break;
50892	50119	}
50893		- case 18446744073709548580LLU: // 99999999Pi'''''''''''''''
	50120	+ case 18446744073709548627LLU: // 99999999QS'''''''''''''''
50894	50121	{
50895	50122	fprintf(stdout, "%s", "\n state.addr = !list_push_move(&heap, ");
50896	50123	fprintf(stdout, "%s", "&");

		@@ -50900,7 +50127,7 @@
50900	50127	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50901	50128	}
50902	50129	// ACCUMULATE ARGUMENTS - END
50903		- uint64_t return_to = 18446744073709548576LLU;
	50130	+ uint64_t return_to = 18446744073709548623LLU;
50904	50131	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50905	50132	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50906	50133	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50909,12 +50136,12 @@
50909	50136	state.addr = 839519719621918720LLU; // skipws____
50910	50137	break;
50911	50138	}
50912		- case 18446744073709548576LLU: // 99999999Pe'''''''''''''''
	50139	+ case 18446744073709548623LLU: // 99999999QO'''''''''''''''
50913	50140	{
50914		- state.addr = 18446744073709548577LLU; // 99999999Pf'''''''''''''''
	50141	+ state.addr = 18446744073709548624LLU; // 99999999QP'''''''''''''''
50915	50142	break;
50916	50143	}
50917		- case 18446744073709548577LLU: // 99999999Pf'''''''''''''''
	50144	+ case 18446744073709548624LLU: // 99999999QP'''''''''''''''
50918	50145	{
50919	50146	/elemid____/LOCAL_ACCESS(heap.data, 19LLU, 17LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 8LLU)));
50920	50147	{

		@@ -50990,7 +50217,7 @@
50990	50217	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50991	50218	}
50992	50219	// ACCUMULATE ARGUMENTS - END
50993		- uint64_t return_to = 18446744073709548573LLU;
	50220	+ uint64_t return_to = 18446744073709548620LLU;
50994	50221	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
50995	50222	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50996	50223	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50999,12 +50226,12 @@
50999	50226	state.addr = 604790753280317473LLU; // findvarref
51000	50227	break;
51001	50228	}
51002		- case 18446744073709548573LLU: // 99999999Pb'''''''''''''''
	50229	+ case 18446744073709548620LLU: // 99999999QL'''''''''''''''
51003	50230	{
51004		- state.addr = 18446744073709548574LLU; // 99999999Pc'''''''''''''''
	50231	+ state.addr = 18446744073709548621LLU; // 99999999QM'''''''''''''''
51005	50232	break;
51006	50233	}
51007		- case 18446744073709548574LLU: // 99999999Pc'''''''''''''''
	50234	+ case 18446744073709548621LLU: // 99999999QM'''''''''''''''
51008	50235	{
51009	50236	// variable u64 consume___ goes out of scope
51010	50237	// emitted destructur for type u64

		@@ -51012,15 +50239,15 @@
51012	50239	// variable u64 optelem___ goes out of scope
51013	50240	// emitted destructur for type u64
51014	50241	(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'''''''''''''''
51016	50243	break;
51017	50244	}
51018		- case 18446744073709548575LLU: // 99999999Pd'''''''''''''''
	50245	+ case 18446744073709548622LLU: // 99999999QN'''''''''''''''
51019	50246	{
51020		- state.addr = /parameter_/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709548572LLU : 18446744073709548571LLU;
	50247	+ state.addr = /parameter_/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709548619LLU : 18446744073709548618LLU;
51021	50248	break;
51022	50249	}
51023		- case 18446744073709548572LLU: // 99999999Pa'''''''''''''''
	50250	+ case 18446744073709548619LLU: // 99999999QK'''''''''''''''
51024	50251	{
51025	50252	fprintf(stderr, "%s", "in function ");
51026	50253	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));

		@@ -51031,22 +50258,22 @@
51031	50258	fprintf(stderr, "%s\n", "");
51032	50259	exit(-1);
51033	50260	}
51034		- state.addr = 18446744073709548571LLU; // 99999999P$'''''''''''''''
	50261	+ state.addr = 18446744073709548618LLU; // 99999999QJ'''''''''''''''
51035	50262	break;
51036	50263	}
51037		- case 18446744073709548571LLU: // 99999999P$'''''''''''''''
	50264	+ case 18446744073709548618LLU: // 99999999QJ'''''''''''''''
51038	50265	{
51039		- state.addr = /initialize/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548570LLU : 18446744073709548569LLU;
	50266	+ state.addr = /initialize/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548617LLU : 18446744073709548616LLU;
51040	50267	break;
51041	50268	}
51042		- case 18446744073709548570LLU: // 99999999PZ'''''''''''''''
	50269	+ case 18446744073709548617LLU: // 99999999QI'''''''''''''''
51043	50270	{
51044	50271	heap.availilable_size_for_dynamic_objects += 0LLU;
51045	50272	heap.availilable_size_for_dynamic_objects += 0LLU;
51046		- state.addr = 18446744073709548568LLU; // 99999999PX'''''''''''''''
	50273	+ state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
51047	50274	break;
51048	50275	}
51049		- case 18446744073709548569LLU: // 99999999PY'''''''''''''''
	50276	+ case 18446744073709548616LLU: // 99999999QH'''''''''''''''
51050	50277	{
51051	50278	// ACCUMULATE ARGUMENTS - BEGIN
51052	50279	{

		@@ -51054,7 +50281,7 @@
51054	50281	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51055	50282	}
51056	50283	// ACCUMULATE ARGUMENTS - END
51057		- uint64_t return_to = 18446744073709548566LLU;
	50284	+ uint64_t return_to = 18446744073709548613LLU;
51058	50285	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51059	50286	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51060	50287	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51063,12 +50290,12 @@
51063	50290	state.addr = 819847183515949359LLU; // reportinit
51064	50291	break;
51065	50292	}
51066		- case 18446744073709548566LLU: // 99999999PV'''''''''''''''
	50293	+ case 18446744073709548613LLU: // 99999999QE'''''''''''''''
51067	50294	{
51068		- state.addr = 18446744073709548567LLU; // 99999999PW'''''''''''''''
	50295	+ state.addr = 18446744073709548614LLU; // 99999999QF'''''''''''''''
51069	50296	break;
51070	50297	}
51071		- case 18446744073709548567LLU: // 99999999PW'''''''''''''''
	50298	+ case 18446744073709548614LLU: // 99999999QF'''''''''''''''
51072	50299	{
51073	50300	fprintf(stderr, "%s", "[ifpushfail] unitialized variable ");
51074	50301	printid(stderr, /elemid____/*LOCAL_ACCESS(heap.data, 22LLU, 17LLU));

		@@ -51076,10 +50303,10 @@
51076	50303	fprintf(stderr, "%s\n", "");
51077	50304	exit(-1);
51078	50305	}
51079		- state.addr = 18446744073709548568LLU; // 99999999PX'''''''''''''''
	50306	+ state.addr = 18446744073709548615LLU; // 99999999QG'''''''''''''''
51080	50307	break;
51081	50308	}
51082		- case 18446744073709548568LLU: // 99999999PX'''''''''''''''
	50309	+ case 18446744073709548615LLU: // 99999999QG'''''''''''''''
51083	50310	{
51084	50311	// ACCUMULATE ARGUMENTS - BEGIN
51085	50312	{

		@@ -51103,7 +50330,7 @@
51103	50330	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51104	50331	}
51105	50332	// ACCUMULATE ARGUMENTS - END
51106		- uint64_t return_to = 18446744073709548564LLU;
	50333	+ uint64_t return_to = 18446744073709548611LLU;
51107	50334	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
51108	50335	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51109	50336	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51112,12 +50339,12 @@
51112	50339	state.addr = 587881357514113024LLU; // emitpar___
51113	50340	break;
51114	50341	}
51115		- case 18446744073709548564LLU: // 99999999PT'''''''''''''''
	50342	+ case 18446744073709548611LLU: // 99999999QC'''''''''''''''
51116	50343	{
51117		- state.addr = 18446744073709548565LLU; // 99999999PU'''''''''''''''
	50344	+ state.addr = 18446744073709548612LLU; // 99999999QD'''''''''''''''
51118	50345	break;
51119	50346	}
51120		- case 18446744073709548565LLU: // 99999999PU'''''''''''''''
	50347	+ case 18446744073709548612LLU: // 99999999QD'''''''''''''''
51121	50348	{
51122	50349	// variable u64 initialize goes out of scope
51123	50350	// emitted destructur for type u64

		@@ -51128,10 +50355,10 @@
51128	50355	// variable u64 mutable___ goes out of scope
51129	50356	// emitted destructur for type u64
51130	50357	(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'''''''''''''''
51132	50359	break;
51133	50360	}
51134		- case 18446744073709548578LLU: // 99999999Pg'''''''''''''''
	50361	+ case 18446744073709548625LLU: // 99999999QQ'''''''''''''''
51135	50362	{
51136	50363	fprintf(stdout, "%s", ", ");
51137	50364	{

		@@ -51150,10 +50377,10 @@
51150	50377	};
51151	50378	*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = arg;
51152	50379	}
51153		- state.addr = 18446744073709548563LLU; // 99999999PS'''''''''''''''
	50380	+ state.addr = 18446744073709548610LLU; // 99999999QB'''''''''''''''
51154	50381	break;
51155	50382	}
51156		- case 18446744073709548563LLU: // 99999999PS'''''''''''''''
	50383	+ case 18446744073709548610LLU: // 99999999QB'''''''''''''''
51157	50384	{
51158	50385	fprintf(stdout, "%s", "&");
51159	50386	{

		@@ -51166,7 +50393,7 @@
51166	50393	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51167	50394	}
51168	50395	// ACCUMULATE ARGUMENTS - END
51169		- uint64_t return_to = 18446744073709548560LLU;
	50396	+ uint64_t return_to = 18446744073709548607LLU;
51170	50397	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51171	50398	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51172	50399	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51175,12 +50402,12 @@
51175	50402	state.addr = 839519719621918720LLU; // skipws____
51176	50403	break;
51177	50404	}
51178		- case 18446744073709548560LLU: // 99999999PP'''''''''''''''
	50405	+ case 18446744073709548607LLU: // 99999999P9'''''''''''''''
51179	50406	{
51180		- state.addr = 18446744073709548561LLU; // 99999999PQ'''''''''''''''
	50407	+ state.addr = 18446744073709548608LLU; // 99999999Q_'''''''''''''''
51181	50408	break;
51182	50409	}
51183		- case 18446744073709548561LLU: // 99999999PQ'''''''''''''''
	50410	+ case 18446744073709548608LLU: // 99999999Q_'''''''''''''''
51184	50411	{
51185	50412	/id________/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 8LLU)));
51186	50413	{

		@@ -51261,7 +50488,7 @@
51261	50488	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51262	50489	}
51263	50490	// ACCUMULATE ARGUMENTS - END
51264		- uint64_t return_to = 18446744073709548558LLU;
	50491	+ uint64_t return_to = 18446744073709548605LLU;
51265	50492	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
51266	50493	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51267	50494	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51270,17 +50497,17 @@
51270	50497	state.addr = 787472342492567585LLU; // procvarref
51271	50498	break;
51272	50499	}
51273		- case 18446744073709548558LLU: // 99999999PN'''''''''''''''
	50500	+ case 18446744073709548605LLU: // 99999999P7'''''''''''''''
51274	50501	{
51275		- state.addr = 18446744073709548559LLU; // 99999999PO'''''''''''''''
	50502	+ state.addr = 18446744073709548606LLU; // 99999999P8'''''''''''''''
51276	50503	break;
51277	50504	}
51278		- case 18446744073709548559LLU: // 99999999PO'''''''''''''''
	50505	+ case 18446744073709548606LLU: // 99999999P8'''''''''''''''
51279	50506	{
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;
51281	50508	break;
51282	50509	}
51283		- case 18446744073709548557LLU: // 99999999PM'''''''''''''''
	50510	+ case 18446744073709548604LLU: // 99999999P6'''''''''''''''
51284	50511	{
51285	50512	{
51286	50513	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 @@
51308	50535	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51309	50536	}
51310	50537	// ACCUMULATE ARGUMENTS - END
51311		- uint64_t return_to = 18446744073709548554LLU;
	50538	+ uint64_t return_to = 18446744073709548601LLU;
51312	50539	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
51313	50540	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51314	50541	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51317,12 +50544,12 @@
51317	50544	state.addr = 367395566849966080LLU; // TYPEINIT__
51318	50545	break;
51319	50546	}
51320		- case 18446744073709548554LLU: // 99999999PJ'''''''''''''''
	50547	+ case 18446744073709548601LLU: // 99999999P3'''''''''''''''
51321	50548	{
51322		- state.addr = 18446744073709548555LLU; // 99999999PK'''''''''''''''
	50549	+ state.addr = 18446744073709548602LLU; // 99999999P4'''''''''''''''
51323	50550	break;
51324	50551	}
51325		- case 18446744073709548555LLU: // 99999999PK'''''''''''''''
	50552	+ case 18446744073709548602LLU: // 99999999P4'''''''''''''''
51326	50553	{
51327	50554	// ACCUMULATE ARGUMENTS - BEGIN
51328	50555	{

		@@ -51342,7 +50569,7 @@
51342	50569	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51343	50570	}
51344	50571	// ACCUMULATE ARGUMENTS - END
51345		- uint64_t return_to = 18446744073709548552LLU;
	50572	+ uint64_t return_to = 18446744073709548599LLU;
51346	50573	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51347	50574	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51348	50575	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51351,12 +50578,12 @@
51351	50578	state.addr = 861504774606571689LLU; // typeassign
51352	50579	break;
51353	50580	}
51354		- case 18446744073709548552LLU: // 99999999PH'''''''''''''''
	50581	+ case 18446744073709548599LLU: // 99999999P1'''''''''''''''
51355	50582	{
51356		- state.addr = 18446744073709548553LLU; // 99999999PI'''''''''''''''
	50583	+ state.addr = 18446744073709548600LLU; // 99999999P2'''''''''''''''
51357	50584	break;
51358	50585	}
51359		- case 18446744073709548553LLU: // 99999999PI'''''''''''''''
	50586	+ case 18446744073709548600LLU: // 99999999P2'''''''''''''''
51360	50587	{
51361	50588	// variable type______ tmp_______ goes out of scope
51362	50589	// emitted destructur for type type______

		@@ -51366,7 +50593,7 @@
51366	50593	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51367	50594	}
51368	50595	// ACCUMULATE ARGUMENTS - END
51369		- uint64_t return_to = 18446744073709548551LLU;
	50596	+ uint64_t return_to = 18446744073709548598LLU;
51370	50597	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51371	50598	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51372	50599	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51375,7 +50602,7 @@
51375	50602	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
51376	50603	break;
51377	50604	}
51378		- case 18446744073709548551LLU: // 99999999PG'''''''''''''''
	50605	+ case 18446744073709548598LLU: // 99999999P0'''''''''''''''
51379	50606	{
51380	50607	(void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp_______ at 29
51381	50608	// variable u64 zero______ goes out of scope

		@@ -51385,10 +50612,10 @@
51385	50612	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference subtype___ at 27
51386	50613	heap.availilable_size_for_dynamic_objects += 0LLU;
51387	50614	heap.availilable_size_for_dynamic_objects += 0LLU;
51388		- state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
	50615	+ state.addr = 18446744073709548597LLU; // 99999999Pz'''''''''''''''
51389	50616	break;
51390	50617	}
51391		- case 18446744073709548556LLU: // 99999999PL'''''''''''''''
	50618	+ case 18446744073709548603LLU: // 99999999P5'''''''''''''''
51392	50619	{
51393	50620	printid(stderr, /callee_id_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 26LLU, 7LLU)));
51394	50621	fprintf(stderr, "%s", ": need list but found ");

		@@ -51398,7 +50625,7 @@
51398	50625	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51399	50626	}
51400	50627	// ACCUMULATE ARGUMENTS - END
51401		- uint64_t return_to = 18446744073709548548LLU;
	50628	+ uint64_t return_to = 18446744073709548595LLU;
51402	50629	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51403	50630	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51404	50631	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51407,21 +50634,21 @@
51407	50634	state.addr = 819847183518878432LLU; // reporttype
51408	50635	break;
51409	50636	}
51410		- case 18446744073709548548LLU: // 99999999PD'''''''''''''''
	50637	+ case 18446744073709548595LLU: // 99999999Px'''''''''''''''
51411	50638	{
51412		- state.addr = 18446744073709548549LLU; // 99999999PE'''''''''''''''
	50639	+ state.addr = 18446744073709548596LLU; // 99999999Py'''''''''''''''
51413	50640	break;
51414	50641	}
51415		- case 18446744073709548549LLU: // 99999999PE'''''''''''''''
	50642	+ case 18446744073709548596LLU: // 99999999Py'''''''''''''''
51416	50643	{
51417	50644	{
51418	50645	fprintf(stderr, "%s\n", "");
51419	50646	exit(-1);
51420	50647	}
51421		- state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
	50648	+ state.addr = 18446744073709548597LLU; // 99999999Pz'''''''''''''''
51422	50649	break;
51423	50650	}
51424		- case 18446744073709548550LLU: // 99999999PF'''''''''''''''
	50651	+ case 18446744073709548597LLU: // 99999999Pz'''''''''''''''
51425	50652	{
51426	50653	{
51427	50654	uint64_t arg = 2LLU;

		@@ -51449,7 +50676,7 @@
51449	50676	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51450	50677	}
51451	50678	// ACCUMULATE ARGUMENTS - END
51452		- uint64_t return_to = 18446744073709548546LLU;
	50679	+ uint64_t return_to = 18446744073709548593LLU;
51453	50680	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
51454	50681	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51455	50682	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51458,12 +50685,12 @@
51458	50685	state.addr = 734295421765213120LLU; // mutassert_
51459	50686	break;
51460	50687	}
51461		- case 18446744073709548546LLU: // 99999999PB'''''''''''''''
	50688	+ case 18446744073709548593LLU: // 99999999Pv'''''''''''''''
51462	50689	{
51463		- state.addr = 18446744073709548547LLU; // 99999999PC'''''''''''''''
	50690	+ state.addr = 18446744073709548594LLU; // 99999999Pw'''''''''''''''
51464	50691	break;
51465	50692	}
51466		- case 18446744073709548547LLU: // 99999999PC'''''''''''''''
	50693	+ case 18446744073709548594LLU: // 99999999Pw'''''''''''''''
51467	50694	{
51468	50695	// variable u64 parnr_____ goes out of scope
51469	50696	// emitted destructur for type u64

		@@ -51483,10 +50710,10 @@
51483	50710	// variable u64 id________ goes out of scope
51484	50711	// emitted destructur for type u64
51485	50712	(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'''''''''''''''
51487	50714	break;
51488	50715	}
51489		- case 18446744073709548562LLU: // 99999999PR'''''''''''''''
	50716	+ case 18446744073709548609LLU: // 99999999QA'''''''''''''''
51490	50717	{
51491	50718	{
51492	50719	uint64_t arg = 0LLU;

		@@ -51510,7 +50737,7 @@
51510	50737	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51511	50738	}
51512	50739	// ACCUMULATE ARGUMENTS - END
51513		- uint64_t return_to = 18446744073709548543LLU;
	50740	+ uint64_t return_to = 18446744073709548590LLU;
51514	50741	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51515	50742	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51516	50743	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51519,12 +50746,12 @@
51519	50746	state.addr = 375116000798050091LLU; // TypeOnHeap
51520	50747	break;
51521	50748	}
51522		- case 18446744073709548543LLU: // 99999999O9'''''''''''''''
	50749	+ case 18446744073709548590LLU: // 99999999Ps'''''''''''''''
51523	50750	{
51524		- state.addr = 18446744073709548544LLU; // 99999999P_'''''''''''''''
	50751	+ state.addr = 18446744073709548591LLU; // 99999999Pt'''''''''''''''
51525	50752	break;
51526	50753	}
51527		- case 18446744073709548544LLU: // 99999999P_'''''''''''''''
	50754	+ case 18446744073709548591LLU: // 99999999Pt'''''''''''''''
51528	50755	{
51529	50756	++/reqsize___/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU);
51530	50757	fprintf(stdout, "%s", ", ");

		@@ -51532,10 +50759,10 @@
51532	50759	// variable u64 reqsize___ goes out of scope
51533	50760	// emitted destructur for type u64
51534	50761	(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'''''''''''''''
51536	50763	break;
51537	50764	}
51538		- case 18446744073709548545LLU: // 99999999PA'''''''''''''''
	50765	+ case 18446744073709548592LLU: // 99999999Pu'''''''''''''''
51539	50766	{
51540	50767	fprintf(stdout, "%s", ") ? ");
51541	50768	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -51544,7 +50771,7 @@
51544	50771	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51545	50772	}
51546	50773	// ACCUMULATE ARGUMENTS - END
51547		- uint64_t return_to = 18446744073709548541LLU;
	50774	+ uint64_t return_to = 18446744073709548588LLU;
51548	50775	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51549	50776	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51550	50777	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51553,12 +50780,12 @@
51553	50780	state.addr = 787446708198178816LLU; // printnr___
51554	50781	break;
51555	50782	}
51556		- case 18446744073709548541LLU: // 99999999O7'''''''''''''''
	50783	+ case 18446744073709548588LLU: // 99999999Pq'''''''''''''''
51557	50784	{
51558		- state.addr = 18446744073709548542LLU; // 99999999O8'''''''''''''''
	50785	+ state.addr = 18446744073709548589LLU; // 99999999Pr'''''''''''''''
51559	50786	break;
51560	50787	}
51561		- case 18446744073709548542LLU: // 99999999O8'''''''''''''''
	50788	+ case 18446744073709548589LLU: // 99999999Pr'''''''''''''''
51562	50789	{
51563	50790	fprintf(stdout, "%s", " : ");
51564	50791	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -51567,7 +50794,7 @@
51567	50794	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51568	50795	}
51569	50796	// ACCUMULATE ARGUMENTS - END
51570		- uint64_t return_to = 18446744073709548539LLU;
	50797	+ uint64_t return_to = 18446744073709548586LLU;
51571	50798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51572	50799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51573	50800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51576,12 +50803,12 @@
51576	50803	state.addr = 787446708198178816LLU; // printnr___
51577	50804	break;
51578	50805	}
51579		- case 18446744073709548539LLU: // 99999999O5'''''''''''''''
	50806	+ case 18446744073709548586LLU: // 99999999Po'''''''''''''''
51580	50807	{
51581		- state.addr = 18446744073709548540LLU; // 99999999O6'''''''''''''''
	50808	+ state.addr = 18446744073709548587LLU; // 99999999Pp'''''''''''''''
51582	50809	break;
51583	50810	}
51584		- case 18446744073709548540LLU: // 99999999O6'''''''''''''''
	50811	+ case 18446744073709548587LLU: // 99999999Pp'''''''''''''''
51585	50812	{
51586	50813	fprintf(stdout, "%s", ";");
51587	50814	{

		@@ -51594,7 +50821,7 @@
51594	50821	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51595	50822	}
51596	50823	// ACCUMULATE ARGUMENTS - END
51597		- uint64_t return_to = 18446744073709548536LLU;
	50824	+ uint64_t return_to = 18446744073709548583LLU;
51598	50825	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51599	50826	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51600	50827	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51603,20 +50830,20 @@
51603	50830	state.addr = 587881351406074923LLU; // emitjumpup
51604	50831	break;
51605	50832	}
51606		- case 18446744073709548536LLU: // 99999999O2'''''''''''''''
	50833	+ case 18446744073709548583LLU: // 99999999Pl'''''''''''''''
51607	50834	{
51608		- state.addr = 18446744073709548537LLU; // 99999999O3'''''''''''''''
	50835	+ state.addr = 18446744073709548584LLU; // 99999999Pm'''''''''''''''
51609	50836	break;
51610	50837	}
51611		- case 18446744073709548537LLU: // 99999999O3'''''''''''''''
	50838	+ case 18446744073709548584LLU: // 99999999Pm'''''''''''''''
51612	50839	{
51613	50840	// variable u64 level_____ goes out of scope
51614	50841	// emitted destructur for type u64
51615	50842	(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'''''''''''''''
51617	50844	break;
51618	50845	}
51619		- case 18446744073709548538LLU: // 99999999O4'''''''''''''''
	50846	+ case 18446744073709548585LLU: // 99999999Pn'''''''''''''''
51620	50847	{
51621	50848	// ACCUMULATE ARGUMENTS - BEGIN
51622	50849	{

		@@ -51624,7 +50851,7 @@
51624	50851	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51625	50852	}
51626	50853	// ACCUMULATE ARGUMENTS - END
51627		- uint64_t return_to = 18446744073709548534LLU;
	50854	+ uint64_t return_to = 18446744073709548581LLU;
51628	50855	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51629	50856	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51630	50857	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51633,12 +50860,12 @@
51633	50860	state.addr = 587881345921715008LLU; // emitenter_
51634	50861	break;
51635	50862	}
51636		- case 18446744073709548534LLU: // 99999999O0'''''''''''''''
	50863	+ case 18446744073709548581LLU: // 99999999Pj'''''''''''''''
51637	50864	{
51638		- state.addr = 18446744073709548535LLU; // 99999999O1'''''''''''''''
	50865	+ state.addr = 18446744073709548582LLU; // 99999999Pk'''''''''''''''
51639	50866	break;
51640	50867	}
51641		- case 18446744073709548535LLU: // 99999999O1'''''''''''''''
	50868	+ case 18446744073709548582LLU: // 99999999Pk'''''''''''''''
51642	50869	{
51643	50870	// variable type______ type0_____ goes out of scope
51644	50871	// emitted destructur for type type______

		@@ -51648,7 +50875,7 @@
51648	50875	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51649	50876	}
51650	50877	// ACCUMULATE ARGUMENTS - END
51651		- uint64_t return_to = 18446744073709548533LLU;
	50878	+ uint64_t return_to = 18446744073709548580LLU;
51652	50879	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51653	50880	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51654	50881	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51657,16 +50884,16 @@
51657	50884	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
51658	50885	break;
51659	50886	}
51660		- case 18446744073709548533LLU: // 99999999Oz'''''''''''''''
	50887	+ case 18446744073709548580LLU: // 99999999Pi'''''''''''''''
51661	50888	{
51662	50889	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type0_____ at 21
51663	50890	// variable u64 INDIRECT0_ goes out of scope
51664	50891	// emitted destructur for type u64
51665	50892	(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'''''''''''''''
51667	50894	break;
51668	50895	}
51669		- case 18446744073709548579LLU: // 99999999Ph'''''''''''''''
	50896	+ case 18446744073709548626LLU: // 99999999QR'''''''''''''''
51670	50897	{
51671	50898	{
51672	50899	uint64_t arg = 0LLU;

		@@ -51690,7 +50917,7 @@
51690	50917	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51691	50918	}
51692	50919	// ACCUMULATE ARGUMENTS - END
51693		- uint64_t return_to = 18446744073709548531LLU;
	50920	+ uint64_t return_to = 18446744073709548578LLU;
51694	50921	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51695	50922	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51696	50923	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51699,12 +50926,12 @@
51699	50926	state.addr = 732615645798520865LLU; // movevarref
51700	50927	break;
51701	50928	}
51702		- case 18446744073709548531LLU: // 99999999Ox'''''''''''''''
	50929	+ case 18446744073709548578LLU: // 99999999Pg'''''''''''''''
51703	50930	{
51704		- state.addr = 18446744073709548532LLU; // 99999999Oy'''''''''''''''
	50931	+ state.addr = 18446744073709548579LLU; // 99999999Ph'''''''''''''''
51705	50932	break;
51706	50933	}
51707		- case 18446744073709548532LLU: // 99999999Oy'''''''''''''''
	50934	+ case 18446744073709548579LLU: // 99999999Ph'''''''''''''''
51708	50935	{
51709	50936	{
51710	50937	uint64_t arg = 0LLU;

		@@ -51748,7 +50975,7 @@
51748	50975	LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51749	50976	}
51750	50977	// ACCUMULATE ARGUMENTS - END
51751		- uint64_t return_to = 18446744073709548528LLU;
	50978	+ uint64_t return_to = 18446744073709548575LLU;
51752	50979	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0));
51753	50980	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51754	50981	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51757,12 +50984,12 @@
51757	50984	state.addr = 533581901819281408LLU; // blockif___
51758	50985	break;
51759	50986	}
51760		- case 18446744073709548528LLU: // 99999999Ou'''''''''''''''
	50987	+ case 18446744073709548575LLU: // 99999999Pd'''''''''''''''
51761	50988	{
51762		- state.addr = 18446744073709548529LLU; // 99999999Ov'''''''''''''''
	50989	+ state.addr = 18446744073709548576LLU; // 99999999Pe'''''''''''''''
51763	50990	break;
51764	50991	}
51765		- case 18446744073709548529LLU: // 99999999Ov'''''''''''''''
	50992	+ case 18446744073709548576LLU: // 99999999Pe'''''''''''''''
51766	50993	{
51767	50994	// variable u64 borrowheap goes out of scope
51768	50995	// emitted destructur for type u64

		@@ -51770,10 +50997,10 @@
51770	50997	// variable u64 borrowsize goes out of scope
51771	50998	// emitted destructur for type u64
51772	50999	(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'''''''''''''''
51774	51001	break;
51775	51002	}
51776		- case 18446744073709548530LLU: // 99999999Ow'''''''''''''''
	51003	+ case 18446744073709548577LLU: // 99999999Pf'''''''''''''''
51777	51004	{
51778	51005	// ACCUMULATE ARGUMENTS - BEGIN
51779	51006	{

		@@ -51781,7 +51008,7 @@
51781	51008	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51782	51009	}
51783	51010	// ACCUMULATE ARGUMENTS - END
51784		- uint64_t return_to = 18446744073709548526LLU;
	51011	+ uint64_t return_to = 18446744073709548573LLU;
51785	51012	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51786	51013	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51787	51014	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51790,12 +51017,12 @@
51790	51017	state.addr = 839519719621918720LLU; // skipws____
51791	51018	break;
51792	51019	}
51793		- case 18446744073709548526LLU: // 99999999Os'''''''''''''''
	51020	+ case 18446744073709548573LLU: // 99999999Pb'''''''''''''''
51794	51021	{
51795		- state.addr = 18446744073709548527LLU; // 99999999Ot'''''''''''''''
	51022	+ state.addr = 18446744073709548574LLU; // 99999999Pc'''''''''''''''
51796	51023	break;
51797	51024	}
51798		- case 18446744073709548527LLU: // 99999999Ot'''''''''''''''
	51025	+ case 18446744073709548574LLU: // 99999999Pc'''''''''''''''
51799	51026	{
51800	51027	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 8LLU)), stdin);
51801	51028	if('{' != (char)getchar())

		@@ -51817,7 +51044,7 @@
51817	51044	}
51818	51045	// ACCUMULATE ARGUMENTS - BEGIN
51819	51046	// ACCUMULATE ARGUMENTS - END
51820		- uint64_t return_to = 18446744073709548523LLU;
	51047	+ uint64_t return_to = 18446744073709548570LLU;
51821	51048	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
51822	51049	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51823	51050	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51826,12 +51053,12 @@
51826	51053	state.addr = 890787671342055424LLU; // varopen___
51827	51054	break;
51828	51055	}
51829		- case 18446744073709548523LLU: // 99999999Op'''''''''''''''
	51056	+ case 18446744073709548570LLU: // 99999999PZ'''''''''''''''
51830	51057	{
51831		- state.addr = 18446744073709548524LLU; // 99999999Oq'''''''''''''''
	51058	+ state.addr = 18446744073709548571LLU; // 99999999P$'''''''''''''''
51832	51059	break;
51833	51060	}
51834		- case 18446744073709548524LLU: // 99999999Oq'''''''''''''''
	51061	+ case 18446744073709548571LLU: // 99999999P$'''''''''''''''
51835	51062	{
51836	51063	// ACCUMULATE ARGUMENTS - BEGIN
51837	51064	{

		@@ -51855,7 +51082,7 @@
51855	51082	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51856	51083	}
51857	51084	// ACCUMULATE ARGUMENTS - END
51858		- uint64_t return_to = 18446744073709548521LLU;
	51085	+ uint64_t return_to = 18446744073709548568LLU;
51859	51086	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
51860	51087	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51861	51088	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51864,12 +51091,12 @@
51864	51091	state.addr = 587881357514113024LLU; // emitpar___
51865	51092	break;
51866	51093	}
51867		- case 18446744073709548521LLU: // 99999999On'''''''''''''''
	51094	+ case 18446744073709548568LLU: // 99999999PX'''''''''''''''
51868	51095	{
51869		- state.addr = 18446744073709548522LLU; // 99999999Oo'''''''''''''''
	51096	+ state.addr = 18446744073709548569LLU; // 99999999PY'''''''''''''''
51870	51097	break;
51871	51098	}
51872		- case 18446744073709548522LLU: // 99999999Oo'''''''''''''''
	51099	+ case 18446744073709548569LLU: // 99999999PY'''''''''''''''
51873	51100	{
51874	51101	// ACCUMULATE ARGUMENTS - BEGIN
51875	51102	{

		@@ -51893,7 +51120,7 @@
51893	51120	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51894	51121	}
51895	51122	// ACCUMULATE ARGUMENTS - END
51896		- uint64_t return_to = 18446744073709548519LLU;
	51123	+ uint64_t return_to = 18446744073709548566LLU;
51897	51124	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
51898	51125	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51899	51126	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51902,12 +51129,12 @@
51902	51129	state.addr = 890786842582581248LLU; // varclose__
51903	51130	break;
51904	51131	}
51905		- case 18446744073709548519LLU: // 99999999Ol'''''''''''''''
	51132	+ case 18446744073709548566LLU: // 99999999PV'''''''''''''''
51906	51133	{
51907		- state.addr = 18446744073709548520LLU; // 99999999Om'''''''''''''''
	51134	+ state.addr = 18446744073709548567LLU; // 99999999PW'''''''''''''''
51908	51135	break;
51909	51136	}
51910		- case 18446744073709548520LLU: // 99999999Om'''''''''''''''
	51137	+ case 18446744073709548567LLU: // 99999999PW'''''''''''''''
51911	51138	{
51912	51139	{
51913	51140	uint64_t arg = 1LLU;

		@@ -51927,7 +51154,7 @@
51927	51154	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51928	51155	}
51929	51156	// ACCUMULATE ARGUMENTS - END
51930		- uint64_t return_to = 18446744073709548516LLU;
	51157	+ uint64_t return_to = 18446744073709548563LLU;
51931	51158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
51932	51159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51933	51160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51936,12 +51163,12 @@
51936	51163	state.addr = 367395560426147840LLU; // TYPECOPY__
51937	51164	break;
51938	51165	}
51939		- case 18446744073709548516LLU: // 99999999Oi'''''''''''''''
	51166	+ case 18446744073709548563LLU: // 99999999PS'''''''''''''''
51940	51167	{
51941		- state.addr = 18446744073709548517LLU; // 99999999Oj'''''''''''''''
	51168	+ state.addr = 18446744073709548564LLU; // 99999999PT'''''''''''''''
51942	51169	break;
51943	51170	}
51944		- case 18446744073709548517LLU: // 99999999Oj'''''''''''''''
	51171	+ case 18446744073709548564LLU: // 99999999PT'''''''''''''''
51945	51172	{
51946	51173	// ACCUMULATE ARGUMENTS - BEGIN
51947	51174	{

		@@ -51973,7 +51200,7 @@
51973	51200	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51974	51201	}
51975	51202	// ACCUMULATE ARGUMENTS - END
51976		- uint64_t return_to = 18446744073709548514LLU;
	51203	+ uint64_t return_to = 18446744073709548561LLU;
51977	51204	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
51978	51205	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51979	51206	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51982,12 +51209,12 @@
51982	51209	state.addr = 788334703205941248LLU; // pushvar___
51983	51210	break;
51984	51211	}
51985		- case 18446744073709548514LLU: // 99999999Og'''''''''''''''
	51212	+ case 18446744073709548561LLU: // 99999999PQ'''''''''''''''
51986	51213	{
51987		- state.addr = 18446744073709548515LLU; // 99999999Oh'''''''''''''''
	51214	+ state.addr = 18446744073709548562LLU; // 99999999PR'''''''''''''''
51988	51215	break;
51989	51216	}
51990		- case 18446744073709548515LLU: // 99999999Oh'''''''''''''''
	51217	+ case 18446744073709548562LLU: // 99999999PR'''''''''''''''
51991	51218	{
51992	51219	// variable type______ t_________ goes out of scope
51993	51220	// emitted destructur for type type______

		@@ -51997,7 +51224,7 @@
51997	51224	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51998	51225	}
51999	51226	// ACCUMULATE ARGUMENTS - END
52000		- uint64_t return_to = 18446744073709548513LLU;
	51227	+ uint64_t return_to = 18446744073709548560LLU;
52001	51228	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52002	51229	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52003	51230	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52006,16 +51233,16 @@
52006	51233	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
52007	51234	break;
52008	51235	}
52009		- case 18446744073709548513LLU: // 99999999Of'''''''''''''''
	51236	+ case 18446744073709548560LLU: // 99999999PP'''''''''''''''
52010	51237	{
52011	51238	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 25
52012	51239	// variable u64 initialize goes out of scope
52013	51240	// emitted destructur for type u64
52014	51241	(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'''''''''''''''
52016	51243	break;
52017	51244	}
52018		- case 18446744073709548518LLU: // 99999999Ok'''''''''''''''
	51245	+ case 18446744073709548565LLU: // 99999999PU'''''''''''''''
52019	51246	{
52020	51247	// variable u64 mutable___ goes out of scope
52021	51248	// emitted destructur for type u64

		@@ -52026,21 +51253,21 @@
52026	51253	// variable u64 INDIRECT__ goes out of scope
52027	51254	// emitted destructur for type u64
52028	51255	(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'''''''''''''''
52030	51257	break;
52031	51258	}
52032		- case 18446744073709548525LLU: // 99999999Or'''''''''''''''
	51259	+ case 18446744073709548572LLU: // 99999999Pa'''''''''''''''
52033	51260	{
52034	51261	// variable list<resdest___> results___ goes out of scope
52035	51262	// emitted destructur for type list<resdest___>
52036		- state.addr = 18446744073709548511LLU; // 99999999Od'''''''''''''''
	51263	+ state.addr = 18446744073709548558LLU; // 99999999PN'''''''''''''''
52037	51264	break;
52038	51265	}
52039		- case 18446744073709548511LLU: // 99999999Od'''''''''''''''
	51266	+ case 18446744073709548558LLU: // 99999999PN'''''''''''''''
52040	51267	{
52041	51268	if(!LOCAL_ACCESS(heap.data, 20LLU, 19LLU)/list*/)
52042	51269	{
52043		- state.addr = 18446744073709548512LLU; // 99999999Oe'''''''''''''''
	51270	+ state.addr = 18446744073709548559LLU; // 99999999PO'''''''''''''''
52044	51271	break;
52045	51272	}
52046	51273	// temporary list-element

		@@ -52054,7 +51281,7 @@
52054	51281	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52055	51282	}
52056	51283	// ACCUMULATE ARGUMENTS - END
52057		- uint64_t return_to = 18446744073709548510LLU;
	51284	+ uint64_t return_to = 18446744073709548557LLU;
52058	51285	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52059	51286	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52060	51287	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52063,14 +51290,14 @@
52063	51290	state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
52064	51291	break;
52065	51292	}
52066		- case 18446744073709548510LLU: // 99999999Oc'''''''''''''''
	51293	+ case 18446744073709548557LLU: // 99999999PM'''''''''''''''
52067	51294	{
52068	51295	// RELEASE temporary destructor-variable
52069	51296	(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'''''''''''''''
52071	51298	break;
52072	51299	}
52073		- case 18446744073709548512LLU: // 99999999Oe'''''''''''''''
	51300	+ case 18446744073709548559LLU: // 99999999PO'''''''''''''''
52074	51301	{
52075	51302	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 20
52076	51303	// variable type______ type1_____ goes out of scope

		@@ -52081,7 +51308,7 @@
52081	51308	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52082	51309	}
52083	51310	// ACCUMULATE ARGUMENTS - END
52084		- uint64_t return_to = 18446744073709548509LLU;
	51311	+ uint64_t return_to = 18446744073709548556LLU;
52085	51312	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52086	51313	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52087	51314	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52090,7 +51317,7 @@
52090	51317	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
52091	51318	break;
52092	51319	}
52093		- case 18446744073709548509LLU: // 99999999Ob'''''''''''''''
	51320	+ case 18446744073709548556LLU: // 99999999PL'''''''''''''''
52094	51321	{
52095	51322	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type1_____ at 19
52096	51323	// variable u64 elemid____ goes out of scope

		@@ -52156,10 +51383,10 @@
52156	51383	};
52157	51384	*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = arg;
52158	51385	}
52159		- state.addr = 18446744073709548508LLU; // 99999999Oa'''''''''''''''
	51386	+ state.addr = 18446744073709548555LLU; // 99999999PK'''''''''''''''
52160	51387	break;
52161	51388	}
52162		- case 18446744073709548508LLU: // 99999999Oa'''''''''''''''
	51389	+ case 18446744073709548555LLU: // 99999999PK'''''''''''''''
52163	51390	{
52164	51391	{
52165	51392	uint64_t arg = 0LLU;

		@@ -52255,7 +51482,7 @@
52255	51482	LOCAL_PUSH_MOVE(&heap, 17LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52256	51483	}
52257	51484	// ACCUMULATE ARGUMENTS - END
52258		- uint64_t return_to = 18446744073709548505LLU;
	51485	+ uint64_t return_to = 18446744073709548552LLU;
52259	51486	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/address of closure-in-construction*/, 0));
52260	51487	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52261	51488	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 18LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52264,12 +51491,12 @@
52264	51491	state.addr = 787472336050047842LLU; // procpararg
52265	51492	break;
52266	51493	}
52267		- case 18446744073709548505LLU: // 99999999OY'''''''''''''''
	51494	+ case 18446744073709548552LLU: // 99999999PH'''''''''''''''
52268	51495	{
52269		- state.addr = 18446744073709548506LLU; // 99999999OZ'''''''''''''''
	51496	+ state.addr = 18446744073709548553LLU; // 99999999PI'''''''''''''''
52270	51497	break;
52271	51498	}
52272		- case 18446744073709548506LLU: // 99999999OZ'''''''''''''''
	51499	+ case 18446744073709548553LLU: // 99999999PI'''''''''''''''
52273	51500	{
52274	51501	// variable u64 INDIRECT__ goes out of scope
52275	51502	// emitted destructur for type u64

		@@ -52277,10 +51504,10 @@
52277	51504	// variable u64 idx_______ goes out of scope
52278	51505	// emitted destructur for type u64
52279	51506	(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'''''''''''''''
52281	51508	break;
52282	51509	}
52283		- case 18446744073709548507LLU: // 99999999O$'''''''''''''''
	51510	+ case 18446744073709548554LLU: // 99999999PJ'''''''''''''''
52284	51511	{
52285	51512	{
52286	51513	uint64_t arg = 548487458505883648LLU;

		@@ -52304,7 +51531,7 @@
52304	51531	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52305	51532	}
52306	51533	// ACCUMULATE ARGUMENTS - END
52307		- uint64_t return_to = 18446744073709548502LLU;
	51534	+ uint64_t return_to = 18446744073709548549LLU;
52308	51535	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52309	51536	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52310	51537	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52313,12 +51540,12 @@
52313	51540	state.addr = 861504774606571689LLU; // typeassign
52314	51541	break;
52315	51542	}
52316		- case 18446744073709548502LLU: // 99999999OV'''''''''''''''
	51543	+ case 18446744073709548549LLU: // 99999999PE'''''''''''''''
52317	51544	{
52318		- state.addr = 18446744073709548503LLU; // 99999999OW'''''''''''''''
	51545	+ state.addr = 18446744073709548550LLU; // 99999999PF'''''''''''''''
52319	51546	break;
52320	51547	}
52321		- case 18446744073709548503LLU: // 99999999OW'''''''''''''''
	51548	+ case 18446744073709548550LLU: // 99999999PF'''''''''''''''
52322	51549	{
52323	51550	{
52324	51551	uint64_t arg = 0LLU;

		@@ -52351,7 +51578,7 @@
52351	51578	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52352	51579	}
52353	51580	// ACCUMULATE ARGUMENTS - END
52354		- uint64_t return_to = 18446744073709548499LLU;
	51581	+ uint64_t return_to = 18446744073709548546LLU;
52355	51582	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
52356	51583	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52357	51584	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52360,17 +51587,17 @@
52360	51587	state.addr = 734295547157569536LLU; // mutcheck__
52361	51588	break;
52362	51589	}
52363		- case 18446744073709548499LLU: // 99999999OS'''''''''''''''
	51590	+ case 18446744073709548546LLU: // 99999999PB'''''''''''''''
52364	51591	{
52365		- state.addr = 18446744073709548500LLU; // 99999999OT'''''''''''''''
	51592	+ state.addr = 18446744073709548547LLU; // 99999999PC'''''''''''''''
52366	51593	break;
52367	51594	}
52368		- case 18446744073709548500LLU: // 99999999OT'''''''''''''''
	51595	+ case 18446744073709548547LLU: // 99999999PC'''''''''''''''
52369	51596	{
52370		- state.addr = 18446744073709548501LLU; // 99999999OU'''''''''''''''
	51597	+ state.addr = 18446744073709548548LLU; // 99999999PD'''''''''''''''
52371	51598	break;
52372	51599	}
52373		- case 18446744073709548501LLU: // 99999999OU'''''''''''''''
	51600	+ case 18446744073709548548LLU: // 99999999PD'''''''''''''''
52374	51601	{
52375	51602	// variable u64 revparnr__ goes out of scope
52376	51603	// emitted destructur for type u64

		@@ -52378,10 +51605,10 @@
52378	51605	// variable u64 info______ goes out of scope
52379	51606	// emitted destructur for type u64
52380	51607	(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'''''''''''''''
52382	51609	break;
52383	51610	}
52384		- case 18446744073709548504LLU: // 99999999OX'''''''''''''''
	51611	+ case 18446744073709548551LLU: // 99999999PG'''''''''''''''
52385	51612	{
52386	51613	// variable u64 parameter_ goes out of scope
52387	51614	// emitted destructur for type u64

		@@ -52400,7 +51627,7 @@
52400	51627	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52401	51628	}
52402	51629	// ACCUMULATE ARGUMENTS - END
52403		- uint64_t return_to = 18446744073709548498LLU;
	51630	+ uint64_t return_to = 18446744073709548545LLU;
52404	51631	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52405	51632	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52406	51633	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52409,7 +51636,7 @@
52409	51636	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
52410	51637	break;
52411	51638	}
52412		- case 18446744073709548498LLU: // 99999999OR'''''''''''''''
	51639	+ case 18446744073709548545LLU: // 99999999PA'''''''''''''''
52413	51640	{
52414	51641	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typearg___ at 21
52415	51642	// parameter-reference u64 defrs_____ goes out of scope

		@@ -52472,7 +51699,7 @@
52472	51699	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52473	51700	}
52474	51701	// ACCUMULATE ARGUMENTS - END
52475		- uint64_t return_to = 18446744073709548496LLU;
	51702	+ uint64_t return_to = 18446744073709548543LLU;
52476	51703	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
52477	51704	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52478	51705	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52481,17 +51708,17 @@
52481	51708	state.addr = 517555565476695680LLU; // assertu64_
52482	51709	break;
52483	51710	}
52484		- case 18446744073709548496LLU: // 99999999OP'''''''''''''''
	51711	+ case 18446744073709548543LLU: // 99999999O9'''''''''''''''
52485	51712	{
52486		- state.addr = 18446744073709548497LLU; // 99999999OQ'''''''''''''''
	51713	+ state.addr = 18446744073709548544LLU; // 99999999P_'''''''''''''''
52487	51714	break;
52488	51715	}
52489		- case 18446744073709548497LLU: // 99999999OQ'''''''''''''''
	51716	+ case 18446744073709548544LLU: // 99999999P_'''''''''''''''
52490	51717	{
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;
52492	51719	break;
52493	51720	}
52494		- case 18446744073709548495LLU: // 99999999OO'''''''''''''''
	51721	+ case 18446744073709548542LLU: // 99999999O8'''''''''''''''
52495	51722	{
52496	51723	fprintf(stderr, "%s", "can't assign value ");
52497	51724	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -52500,7 +51727,7 @@
52500	51727	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52501	51728	}
52502	51729	// ACCUMULATE ARGUMENTS - END
52503		- uint64_t return_to = 18446744073709548492LLU;
	51730	+ uint64_t return_to = 18446744073709548539LLU;
52504	51731	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52505	51732	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52506	51733	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52509,12 +51736,12 @@
52509	51736	state.addr = 819847183517274112LLU; // reportnr__
52510	51737	break;
52511	51738	}
52512		- case 18446744073709548492LLU: // 99999999OL'''''''''''''''
	51739	+ case 18446744073709548539LLU: // 99999999O5'''''''''''''''
52513	51740	{
52514		- state.addr = 18446744073709548493LLU; // 99999999OM'''''''''''''''
	51741	+ state.addr = 18446744073709548540LLU; // 99999999O6'''''''''''''''
52515	51742	break;
52516	51743	}
52517		- case 18446744073709548493LLU: // 99999999OM'''''''''''''''
	51744	+ case 18446744073709548540LLU: // 99999999O6'''''''''''''''
52518	51745	{
52519	51746	fprintf(stderr, "%s", " to reference-parameter ");
52520	51747	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -52523,7 +51750,7 @@
52523	51750	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52524	51751	}
52525	51752	// ACCUMULATE ARGUMENTS - END
52526		- uint64_t return_to = 18446744073709548490LLU;
	51753	+ uint64_t return_to = 18446744073709548537LLU;
52527	51754	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52528	51755	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52529	51756	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52532,21 +51759,21 @@
52532	51759	state.addr = 819847183517274112LLU; // reportnr__
52533	51760	break;
52534	51761	}
52535		- case 18446744073709548490LLU: // 99999999OJ'''''''''''''''
	51762	+ case 18446744073709548537LLU: // 99999999O3'''''''''''''''
52536	51763	{
52537		- state.addr = 18446744073709548491LLU; // 99999999OK'''''''''''''''
	51764	+ state.addr = 18446744073709548538LLU; // 99999999O4'''''''''''''''
52538	51765	break;
52539	51766	}
52540		- case 18446744073709548491LLU: // 99999999OK'''''''''''''''
	51767	+ case 18446744073709548538LLU: // 99999999O4'''''''''''''''
52541	51768	{
52542	51769	{
52543	51770	fprintf(stderr, "%s\n", "");
52544	51771	exit(-1);
52545	51772	}
52546		- state.addr = 18446744073709548494LLU; // 99999999ON'''''''''''''''
	51773	+ state.addr = 18446744073709548541LLU; // 99999999O7'''''''''''''''
52547	51774	break;
52548	51775	}
52549		- case 18446744073709548494LLU: // 99999999ON'''''''''''''''
	51776	+ case 18446744073709548541LLU: // 99999999O7'''''''''''''''
52550	51777	{
52551	51778	// ACCUMULATE ARGUMENTS - BEGIN
52552	51779	{

		@@ -52554,7 +51781,7 @@
52554	51781	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52555	51782	}
52556	51783	// ACCUMULATE ARGUMENTS - END
52557		- uint64_t return_to = 18446744073709548488LLU;
	51784	+ uint64_t return_to = 18446744073709548535LLU;
52558	51785	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52559	51786	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52560	51787	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52563,12 +51790,12 @@
52563	51790	state.addr = 787446708198178816LLU; // printnr___
52564	51791	break;
52565	51792	}
52566		- case 18446744073709548488LLU: // 99999999OH'''''''''''''''
	51793	+ case 18446744073709548535LLU: // 99999999O1'''''''''''''''
52567	51794	{
52568		- state.addr = 18446744073709548489LLU; // 99999999OI'''''''''''''''
	51795	+ state.addr = 18446744073709548536LLU; // 99999999O2'''''''''''''''
52569	51796	break;
52570	51797	}
52571		- case 18446744073709548489LLU: // 99999999OI'''''''''''''''
	51798	+ case 18446744073709548536LLU: // 99999999O2'''''''''''''''
52572	51799	{
52573	51800	// parameter-reference u64 tmprs_____ goes out of scope
52574	51801	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmprs_____ at 9

		@@ -52598,15 +51825,15 @@
52598	51825	}
52599	51826	case 787472320226257577LLU: // procargcon
52600	51827	{
52601		- state.addr = 1LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 6LLU))].elem0 ? 18446744073709548487LLU : 18446744073709548486LLU;
	51828	+ state.addr = 1LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 6LLU))].elem0 ? 18446744073709548534LLU : 18446744073709548533LLU;
52602	51829	break;
52603	51830	}
52604		- case 18446744073709548487LLU: // 99999999OG'''''''''''''''
	51831	+ case 18446744073709548534LLU: // 99999999O0'''''''''''''''
52605	51832	{
52606		- state.addr = /REFERENCE_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 4LLU)) ? 18446744073709548485LLU : 18446744073709548484LLU;
	51833	+ state.addr = /REFERENCE_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 4LLU)) ? 18446744073709548532LLU : 18446744073709548531LLU;
52607	51834	break;
52608	51835	}
52609		- case 18446744073709548485LLU: // 99999999OE'''''''''''''''
	51836	+ case 18446744073709548532LLU: // 99999999Oy'''''''''''''''
52610	51837	{
52611	51838	// ACCUMULATE ARGUMENTS - BEGIN
52612	51839	{

		@@ -52614,7 +51841,7 @@
52614	51841	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52615	51842	}
52616	51843	// ACCUMULATE ARGUMENTS - END
52617		- uint64_t return_to = 18446744073709548482LLU;
	51844	+ uint64_t return_to = 18446744073709548529LLU;
52618	51845	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52619	51846	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52620	51847	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52623,12 +51850,12 @@
52623	51850	state.addr = 819847183515949359LLU; // reportinit
52624	51851	break;
52625	51852	}
52626		- case 18446744073709548482LLU: // 99999999OB'''''''''''''''
	51853	+ case 18446744073709548529LLU: // 99999999Ov'''''''''''''''
52627	51854	{
52628		- state.addr = 18446744073709548483LLU; // 99999999OC'''''''''''''''
	51855	+ state.addr = 18446744073709548530LLU; // 99999999Ow'''''''''''''''
52629	51856	break;
52630	51857	}
52631		- case 18446744073709548483LLU: // 99999999OC'''''''''''''''
	51858	+ case 18446744073709548530LLU: // 99999999Ow'''''''''''''''
52632	51859	{
52633	51860	fprintf(stderr, "%s", "constructor can only be used as argument for consume-by-value parameter but found call-by-reference");
52634	51861	{

		@@ -52635,10 +51862,10 @@
52635	51862	fprintf(stderr, "%s\n", "");
52636	51863	exit(-1);
52637	51864	}
52638		- state.addr = 18446744073709548484LLU; // 99999999OD'''''''''''''''
	51865	+ state.addr = 18446744073709548531LLU; // 99999999Ox'''''''''''''''
52639	51866	break;
52640	51867	}
52641		- case 18446744073709548484LLU: // 99999999OD'''''''''''''''
	51868	+ case 18446744073709548531LLU: // 99999999Ox'''''''''''''''
52642	51869	{
52643	51870	// ACCUMULATE ARGUMENTS - BEGIN
52644	51871	{

		@@ -52662,7 +51889,7 @@
52662	51889	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52663	51890	}
52664	51891	// ACCUMULATE ARGUMENTS - END
52665		- uint64_t return_to = 18446744073709548480LLU;
	51892	+ uint64_t return_to = 18446744073709548527LLU;
52666	51893	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
52667	51894	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52668	51895	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52671,12 +51898,12 @@
52671	51898	state.addr = 515555125197130432LLU; // allocheap_
52672	51899	break;
52673	51900	}
52674		- case 18446744073709548480LLU: // 99999999O_'''''''''''''''
	51901	+ case 18446744073709548527LLU: // 99999999Ot'''''''''''''''
52675	51902	{
52676		- state.addr = 18446744073709548481LLU; // 99999999OA'''''''''''''''
	51903	+ state.addr = 18446744073709548528LLU; // 99999999Ou'''''''''''''''
52677	51904	break;
52678	51905	}
52679		- case 18446744073709548481LLU: // 99999999OA'''''''''''''''
	51906	+ case 18446744073709548528LLU: // 99999999Ou'''''''''''''''
52680	51907	{
52681	51908	{
52682	51909	uint64_t arg = 0LLU;

		@@ -52738,7 +51965,7 @@
52738	51965	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52739	51966	}
52740	51967	// ACCUMULATE ARGUMENTS - END
52741		- uint64_t return_to = 18446744073709548478LLU;
	51968	+ uint64_t return_to = 18446744073709548525LLU;
52742	51969	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
52743	51970	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52744	51971	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52747,12 +51974,12 @@
52747	51974	state.addr = 54378275173643538LLU; // CALLCONSTR
52748	51975	break;
52749	51976	}
52750		- case 18446744073709548478LLU: // 99999999N8'''''''''''''''
	51977	+ case 18446744073709548525LLU: // 99999999Or'''''''''''''''
52751	51978	{
52752		- state.addr = 18446744073709548479LLU; // 99999999N9'''''''''''''''
	51979	+ state.addr = 18446744073709548526LLU; // 99999999Os'''''''''''''''
52753	51980	break;
52754	51981	}
52755		- case 18446744073709548479LLU: // 99999999N9'''''''''''''''
	51982	+ case 18446744073709548526LLU: // 99999999Os'''''''''''''''
52756	51983	{
52757	51984	// ACCUMULATE ARGUMENTS - BEGIN
52758	51985	{

		@@ -52760,7 +51987,7 @@
52760	51987	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52761	51988	}
52762	51989	// ACCUMULATE ARGUMENTS - END
52763		- uint64_t return_to = 18446744073709548476LLU;
	51990	+ uint64_t return_to = 18446744073709548523LLU;
52764	51991	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52765	51992	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52766	51993	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52769,12 +51996,12 @@
52769	51996	state.addr = 839519719621918720LLU; // skipws____
52770	51997	break;
52771	51998	}
52772		- case 18446744073709548476LLU: // 99999999N6'''''''''''''''
	51999	+ case 18446744073709548523LLU: // 99999999Op'''''''''''''''
52773	52000	{
52774		- state.addr = 18446744073709548477LLU; // 99999999N7'''''''''''''''
	52001	+ state.addr = 18446744073709548524LLU; // 99999999Oq'''''''''''''''
52775	52002	break;
52776	52003	}
52777		- case 18446744073709548477LLU: // 99999999N7'''''''''''''''
	52004	+ case 18446744073709548524LLU: // 99999999Oq'''''''''''''''
52778	52005	{
52779	52006	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 14LLU)));
52780	52007	// variable u64 varid_____ goes out of scope

		@@ -52785,10 +52012,10 @@
52785	52012	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 22
52786	52013	heap.availilable_size_for_dynamic_objects += 0LLU;
52787	52014	heap.availilable_size_for_dynamic_objects += 0LLU;
52788		- state.addr = 18446744073709548475LLU; // 99999999N5'''''''''''''''
	52015	+ state.addr = 18446744073709548522LLU; // 99999999Oo'''''''''''''''
52789	52016	break;
52790	52017	}
52791		- case 18446744073709548486LLU: // 99999999OF'''''''''''''''
	52018	+ case 18446744073709548533LLU: // 99999999Oz'''''''''''''''
52792	52019	{
52793	52020	// ACCUMULATE ARGUMENTS - BEGIN
52794	52021	{

		@@ -52796,7 +52023,7 @@
52796	52023	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52797	52024	}
52798	52025	// ACCUMULATE ARGUMENTS - END
52799		- uint64_t return_to = 18446744073709548473LLU;
	52026	+ uint64_t return_to = 18446744073709548520LLU;
52800	52027	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52801	52028	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52802	52029	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52805,12 +52032,12 @@
52805	52032	state.addr = 819847183515949359LLU; // reportinit
52806	52033	break;
52807	52034	}
52808		- case 18446744073709548473LLU: // 99999999N3'''''''''''''''
	52035	+ case 18446744073709548520LLU: // 99999999Om'''''''''''''''
52809	52036	{
52810		- state.addr = 18446744073709548474LLU; // 99999999N4'''''''''''''''
	52037	+ state.addr = 18446744073709548521LLU; // 99999999On'''''''''''''''
52811	52038	break;
52812	52039	}
52813		- case 18446744073709548474LLU: // 99999999N4'''''''''''''''
	52040	+ case 18446744073709548521LLU: // 99999999On'''''''''''''''
52814	52041	{
52815	52042	fprintf(stderr, "%s", "constructor can only be used as argument for consume-by-value parameter but found ");
52816	52043	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -52819,7 +52046,7 @@
52819	52046	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52820	52047	}
52821	52048	// ACCUMULATE ARGUMENTS - END
52822		- uint64_t return_to = 18446744073709548471LLU;
	52049	+ uint64_t return_to = 18446744073709548518LLU;
52823	52050	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52824	52051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52825	52052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52828,21 +52055,21 @@
52828	52055	state.addr = 819847183514380911LLU; // reportcont
52829	52056	break;
52830	52057	}
52831		- case 18446744073709548471LLU: // 99999999N1'''''''''''''''
	52058	+ case 18446744073709548518LLU: // 99999999Ok'''''''''''''''
52832	52059	{
52833		- state.addr = 18446744073709548472LLU; // 99999999N2'''''''''''''''
	52060	+ state.addr = 18446744073709548519LLU; // 99999999Ol'''''''''''''''
52834	52061	break;
52835	52062	}
52836		- case 18446744073709548472LLU: // 99999999N2'''''''''''''''
	52063	+ case 18446744073709548519LLU: // 99999999Ol'''''''''''''''
52837	52064	{
52838	52065	{
52839	52066	fprintf(stderr, "%s\n", "");
52840	52067	exit(-1);
52841	52068	}
52842		- state.addr = 18446744073709548475LLU; // 99999999N5'''''''''''''''
	52069	+ state.addr = 18446744073709548522LLU; // 99999999Oo'''''''''''''''
52843	52070	break;
52844	52071	}
52845		- case 18446744073709548475LLU: // 99999999N5'''''''''''''''
	52072	+ case 18446744073709548522LLU: // 99999999Oo'''''''''''''''
52846	52073	{
52847	52074	// parameter-reference u64 remainheap goes out of scope
52848	52075	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainheap at 21

		@@ -52900,10 +52127,10 @@
52900	52127	uint64_t arg = 0LLU;
52901	52128	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
52902	52129	}
52903		- state.addr = /argid_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) ? 18446744073709548470LLU : 18446744073709548469LLU;
	52130	+ state.addr = /argid_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) ? 18446744073709548517LLU : 18446744073709548516LLU;
52904	52131	break;
52905	52132	}
52906		- case 18446744073709548470LLU: // 99999999N0'''''''''''''''
	52133	+ case 18446744073709548517LLU: // 99999999Oj'''''''''''''''
52907	52134	{
52908	52135	*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 40LLU;
52909	52136

		@@ -52913,7 +52140,7 @@
52913	52140	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52914	52141	}
52915	52142	// ACCUMULATE ARGUMENTS - END
52916		- uint64_t return_to = 18446744073709548467LLU;
	52143	+ uint64_t return_to = 18446744073709548514LLU;
52917	52144	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52918	52145	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52919	52146	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52922,18 +52149,18 @@
52922	52149	state.addr = 839519719621918720LLU; // skipws____
52923	52150	break;
52924	52151	}
52925		- case 18446744073709548467LLU: // 99999999Nx'''''''''''''''
	52152	+ case 18446744073709548514LLU: // 99999999Og'''''''''''''''
52926	52153	{
52927		- state.addr = 18446744073709548468LLU; // 99999999Ny'''''''''''''''
	52154	+ state.addr = 18446744073709548515LLU; // 99999999Oh'''''''''''''''
52928	52155	break;
52929	52156	}
52930		- case 18446744073709548468LLU: // 99999999Ny'''''''''''''''
	52157	+ case 18446744073709548515LLU: // 99999999Oh'''''''''''''''
52931	52158	{
52932	52159	/buf_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /buf_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 14LLU));
52933		- state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548466LLU : 18446744073709548465LLU;
	52160	+ state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548513LLU : 18446744073709548512LLU;
52934	52161	break;
52935	52162	}
52936		- case 18446744073709548466LLU: // 99999999Nw'''''''''''''''
	52163	+ case 18446744073709548513LLU: // 99999999Of'''''''''''''''
52937	52164	{
52938	52165	// ACCUMULATE ARGUMENTS - BEGIN
52939	52166	{

		@@ -53021,7 +52248,7 @@
53021	52248	LOCAL_PUSH_MOVE(&heap, 20LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53022	52249	}
53023	52250	// ACCUMULATE ARGUMENTS - END
53024		- uint64_t return_to = 18446744073709548463LLU;
	52251	+ uint64_t return_to = 18446744073709548510LLU;
53025	52252	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/address of closure-in-construction*/, 0));
53026	52253	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53027	52254	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53030,19 +52257,19 @@
53030	52257	state.addr = 787472320226257577LLU; // procargcon
53031	52258	break;
53032	52259	}
53033		- case 18446744073709548463LLU: // 99999999Nt'''''''''''''''
	52260	+ case 18446744073709548510LLU: // 99999999Oc'''''''''''''''
53034	52261	{
53035		- state.addr = 18446744073709548464LLU; // 99999999Nu'''''''''''''''
	52262	+ state.addr = 18446744073709548511LLU; // 99999999Od'''''''''''''''
53036	52263	break;
53037	52264	}
53038		- case 18446744073709548464LLU: // 99999999Nu'''''''''''''''
	52265	+ case 18446744073709548511LLU: // 99999999Od'''''''''''''''
53039	52266	{
53040	52267	heap.availilable_size_for_dynamic_objects += 0LLU;
53041	52268	heap.availilable_size_for_dynamic_objects += 0LLU;
53042		- state.addr = 18446744073709548462LLU; // 99999999Ns'''''''''''''''
	52269	+ state.addr = 18446744073709548509LLU; // 99999999Ob'''''''''''''''
53043	52270	break;
53044	52271	}
53045		- case 18446744073709548465LLU: // 99999999Nv'''''''''''''''
	52272	+ case 18446744073709548512LLU: // 99999999Oe'''''''''''''''
53046	52273	{
53047	52274	// ACCUMULATE ARGUMENTS - BEGIN
53048	52275	{

		@@ -53126,7 +52353,7 @@
53126	52353	LOCAL_PUSH_MOVE(&heap, 19LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53127	52354	}
53128	52355	// ACCUMULATE ARGUMENTS - END
53129		- uint64_t return_to = 18446744073709548460LLU;
	52356	+ uint64_t return_to = 18446744073709548507LLU;
53130	52357	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 20LLU, 0/address of closure-in-construction*/, 0));
53131	52358	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53132	52359	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 20LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53135,24 +52362,24 @@
53135	52362	state.addr = 787472320226281408LLU; // procargid_
53136	52363	break;
53137	52364	}
53138		- case 18446744073709548460LLU: // 99999999Nq'''''''''''''''
	52365	+ case 18446744073709548507LLU: // 99999999O$'''''''''''''''
53139	52366	{
53140		- state.addr = 18446744073709548461LLU; // 99999999Nr'''''''''''''''
	52367	+ state.addr = 18446744073709548508LLU; // 99999999Oa'''''''''''''''
53141	52368	break;
53142	52369	}
53143		- case 18446744073709548461LLU: // 99999999Nr'''''''''''''''
	52370	+ case 18446744073709548508LLU: // 99999999Oa'''''''''''''''
53144	52371	{
53145		- state.addr = 18446744073709548462LLU; // 99999999Ns'''''''''''''''
	52372	+ state.addr = 18446744073709548509LLU; // 99999999Ob'''''''''''''''
53146	52373	break;
53147	52374	}
53148		- case 18446744073709548462LLU: // 99999999Ns'''''''''''''''
	52375	+ case 18446744073709548509LLU: // 99999999Ob'''''''''''''''
53149	52376	{
53150	52377	heap.availilable_size_for_dynamic_objects += 0LLU;
53151	52378	heap.availilable_size_for_dynamic_objects += 0LLU;
53152		- state.addr = 18446744073709548459LLU; // 99999999Np'''''''''''''''
	52379	+ state.addr = 18446744073709548506LLU; // 99999999OZ'''''''''''''''
53153	52380	break;
53154	52381	}
53155		- case 18446744073709548469LLU: // 99999999Nz'''''''''''''''
	52382	+ case 18446744073709548516LLU: // 99999999Oi'''''''''''''''
53156	52383	{
53157	52384	{
53158	52385	uint64_t arg = 0LLU;

		@@ -53197,7 +52424,7 @@
53197	52424	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53198	52425	}
53199	52426	// ACCUMULATE ARGUMENTS - END
53200		- uint64_t return_to = 18446744073709548457LLU;
	52427	+ uint64_t return_to = 18446744073709548504LLU;
53201	52428	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
53202	52429	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53203	52430	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53206,20 +52433,20 @@
53206	52433	state.addr = 787472320226302784LLU; // procargnr_
53207	52434	break;
53208	52435	}
53209		- case 18446744073709548457LLU: // 99999999Nn'''''''''''''''
	52436	+ case 18446744073709548504LLU: // 99999999OX'''''''''''''''
53210	52437	{
53211		- state.addr = 18446744073709548458LLU; // 99999999No'''''''''''''''
	52438	+ state.addr = 18446744073709548505LLU; // 99999999OY'''''''''''''''
53212	52439	break;
53213	52440	}
53214		- case 18446744073709548458LLU: // 99999999No'''''''''''''''
	52441	+ case 18446744073709548505LLU: // 99999999OY'''''''''''''''
53215	52442	{
53216	52443	// variable u64 nr________ goes out of scope
53217	52444	// emitted destructur for type u64
53218	52445	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 23
53219		- state.addr = 18446744073709548459LLU; // 99999999Np'''''''''''''''
	52446	+ state.addr = 18446744073709548506LLU; // 99999999OZ'''''''''''''''
53220	52447	break;
53221	52448	}
53222		- case 18446744073709548459LLU: // 99999999Np'''''''''''''''
	52449	+ case 18446744073709548506LLU: // 99999999OZ'''''''''''''''
53223	52450	{
53224	52451	// variable u64 buf_______ goes out of scope
53225	52452	// emitted destructur for type u64

		@@ -53287,10 +52514,10 @@
53287	52514	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
53288	52515	}
53289	52516	/overflow__/LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 4LLU)) < /totalsize_/LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
53290		- state.addr = /overflow__/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709548456LLU : 18446744073709548455LLU;
	52517	+ state.addr = /overflow__/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709548503LLU : 18446744073709548502LLU;
53291	52518	break;
53292	52519	}
53293		- case 18446744073709548456LLU: // 99999999Nm'''''''''''''''
	52520	+ case 18446744073709548503LLU: // 99999999OW'''''''''''''''
53294	52521	{
53295	52522	fprintf(stderr, "%s", "out of memory calling function ");
53296	52523	printid(stderr, /callee_id_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 1LLU)));

		@@ -53301,7 +52528,7 @@
53301	52528	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53302	52529	}
53303	52530	// ACCUMULATE ARGUMENTS - END
53304		- uint64_t return_to = 18446744073709548453LLU;
	52531	+ uint64_t return_to = 18446744073709548500LLU;
53305	52532	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53306	52533	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53307	52534	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53310,12 +52537,12 @@
53310	52537	state.addr = 819847183517274112LLU; // reportnr__
53311	52538	break;
53312	52539	}
53313		- case 18446744073709548453LLU: // 99999999Nj'''''''''''''''
	52540	+ case 18446744073709548500LLU: // 99999999OT'''''''''''''''
53314	52541	{
53315		- state.addr = 18446744073709548454LLU; // 99999999Nk'''''''''''''''
	52542	+ state.addr = 18446744073709548501LLU; // 99999999OU'''''''''''''''
53316	52543	break;
53317	52544	}
53318		- case 18446744073709548454LLU: // 99999999Nk'''''''''''''''
	52545	+ case 18446744073709548501LLU: // 99999999OU'''''''''''''''
53319	52546	{
53320	52547	fprintf(stderr, "%s", " chunks of memory but caller ");
53321	52548	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 0LLU)));

		@@ -53326,7 +52553,7 @@
53326	52553	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53327	52554	}
53328	52555	// ACCUMULATE ARGUMENTS - END
53329		- uint64_t return_to = 18446744073709548451LLU;
	52556	+ uint64_t return_to = 18446744073709548498LLU;
53330	52557	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53331	52558	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53332	52559	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53335,21 +52562,21 @@
53335	52562	state.addr = 819847183517274112LLU; // reportnr__
53336	52563	break;
53337	52564	}
53338		- case 18446744073709548451LLU: // 99999999Nh'''''''''''''''
	52565	+ case 18446744073709548498LLU: // 99999999OR'''''''''''''''
53339	52566	{
53340		- state.addr = 18446744073709548452LLU; // 99999999Ni'''''''''''''''
	52567	+ state.addr = 18446744073709548499LLU; // 99999999OS'''''''''''''''
53341	52568	break;
53342	52569	}
53343		- case 18446744073709548452LLU: // 99999999Ni'''''''''''''''
	52570	+ case 18446744073709548499LLU: // 99999999OS'''''''''''''''
53344	52571	{
53345	52572	{
53346	52573	fprintf(stderr, "%s\n", "");
53347	52574	exit(-1);
53348	52575	}
53349		- state.addr = 18446744073709548455LLU; // 99999999Nl'''''''''''''''
	52576	+ state.addr = 18446744073709548502LLU; // 99999999OV'''''''''''''''
53350	52577	break;
53351	52578	}
53352		- case 18446744073709548455LLU: // 99999999Nl'''''''''''''''
	52579	+ case 18446744073709548502LLU: // 99999999OV'''''''''''''''
53353	52580	{
53354	52581	// variable u64 overflow__ goes out of scope
53355	52582	// emitted destructur for type u64

		@@ -53407,7 +52634,7 @@
53407	52634	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53408	52635	}
53409	52636	// ACCUMULATE ARGUMENTS - END
53410		- uint64_t return_to = 18446744073709548449LLU;
	52637	+ uint64_t return_to = 18446744073709548496LLU;
53411	52638	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
53412	52639	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53413	52640	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53416,12 +52643,12 @@
53416	52643	state.addr = 533581901922699840LLU; // blockopen_
53417	52644	break;
53418	52645	}
53419		- case 18446744073709548449LLU: // 99999999Nf'''''''''''''''
	52646	+ case 18446744073709548496LLU: // 99999999OP'''''''''''''''
53420	52647	{
53421		- state.addr = 18446744073709548450LLU; // 99999999Ng'''''''''''''''
	52648	+ state.addr = 18446744073709548497LLU; // 99999999OQ'''''''''''''''
53422	52649	break;
53423	52650	}
53424		- case 18446744073709548450LLU: // 99999999Ng'''''''''''''''
	52651	+ case 18446744073709548497LLU: // 99999999OQ'''''''''''''''
53425	52652	{
53426	52653	{
53427	52654	uint64_t arg = 0LLU;

		@@ -53485,7 +52712,7 @@
53485	52712	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53486	52713	}
53487	52714	// ACCUMULATE ARGUMENTS - END
53488		- uint64_t return_to = 18446744073709548446LLU;
	52715	+ uint64_t return_to = 18446744073709548493LLU;
53489	52716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0));
53490	52717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53491	52718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53494,12 +52721,12 @@
53494	52721	state.addr = 621705621980315648LLU; // getdef____
53495	52722	break;
53496	52723	}
53497		- case 18446744073709548446LLU: // 99999999Nc'''''''''''''''
	52724	+ case 18446744073709548493LLU: // 99999999OM'''''''''''''''
53498	52725	{
53499		- state.addr = 18446744073709548447LLU; // 99999999Nd'''''''''''''''
	52726	+ state.addr = 18446744073709548494LLU; // 99999999ON'''''''''''''''
53500	52727	break;
53501	52728	}
53502		- case 18446744073709548447LLU: // 99999999Nd'''''''''''''''
	52729	+ case 18446744073709548494LLU: // 99999999ON'''''''''''''''
53503	52730	{
53504	52731	{
53505	52732	uint64_t arg = 0LLU;

		@@ -53506,10 +52733,10 @@
53506	52733	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
53507	52734	}
53508	52735	/outofheap_/LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /sizeonheap/LOCAL_ACCESS(heap.data, 23LLU, 21LLU) > /remainheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 15LLU));
53509		- state.addr = /outofheap_/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548445LLU : 18446744073709548444LLU;
	52736	+ state.addr = /outofheap_/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548492LLU : 18446744073709548491LLU;
53510	52737	break;
53511	52738	}
53512		- case 18446744073709548445LLU: // 99999999Nb'''''''''''''''
	52739	+ case 18446744073709548492LLU: // 99999999OL'''''''''''''''
53513	52740	{
53514	52741	// ACCUMULATE ARGUMENTS - BEGIN
53515	52742	{

		@@ -53517,7 +52744,7 @@
53517	52744	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53518	52745	}
53519	52746	// ACCUMULATE ARGUMENTS - END
53520		- uint64_t return_to = 18446744073709548442LLU;
	52747	+ uint64_t return_to = 18446744073709548489LLU;
53521	52748	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53522	52749	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53523	52750	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53526,12 +52753,12 @@
53526	52753	state.addr = 819847183515949359LLU; // reportinit
53527	52754	break;
53528	52755	}
53529		- case 18446744073709548442LLU: // 99999999NZ'''''''''''''''
	52756	+ case 18446744073709548489LLU: // 99999999OI'''''''''''''''
53530	52757	{
53531		- state.addr = 18446744073709548443LLU; // 99999999N$'''''''''''''''
	52758	+ state.addr = 18446744073709548490LLU; // 99999999OJ'''''''''''''''
53532	52759	break;
53533	52760	}
53534		- case 18446744073709548443LLU: // 99999999N$'''''''''''''''
	52761	+ case 18446744073709548490LLU: // 99999999OJ'''''''''''''''
53535	52762	{
53536	52763	fprintf(stderr, "%s", "out of heap calling ");
53537	52764	printid(stderr, /callee_id_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 10LLU)));

		@@ -53544,7 +52771,7 @@
53544	52771	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53545	52772	}
53546	52773	// ACCUMULATE ARGUMENTS - END
53547		- uint64_t return_to = 18446744073709548440LLU;
	52774	+ uint64_t return_to = 18446744073709548487LLU;
53548	52775	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53549	52776	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53550	52777	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53553,12 +52780,12 @@
53553	52780	state.addr = 819847183517274112LLU; // reportnr__
53554	52781	break;
53555	52782	}
53556		- case 18446744073709548440LLU: // 99999999NX'''''''''''''''
	52783	+ case 18446744073709548487LLU: // 99999999OG'''''''''''''''
53557	52784	{
53558		- state.addr = 18446744073709548441LLU; // 99999999NY'''''''''''''''
	52785	+ state.addr = 18446744073709548488LLU; // 99999999OH'''''''''''''''
53559	52786	break;
53560	52787	}
53561		- case 18446744073709548441LLU: // 99999999NY'''''''''''''''
	52788	+ case 18446744073709548488LLU: // 99999999OH'''''''''''''''
53562	52789	{
53563	52790	fprintf(stderr, "%s", " but remaining heap-size is ");
53564	52791	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -53567,7 +52794,7 @@
53567	52794	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53568	52795	}
53569	52796	// ACCUMULATE ARGUMENTS - END
53570		- uint64_t return_to = 18446744073709548438LLU;
	52797	+ uint64_t return_to = 18446744073709548485LLU;
53571	52798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53572	52799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53573	52800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53576,30 +52803,30 @@
53576	52803	state.addr = 819847183517274112LLU; // reportnr__
53577	52804	break;
53578	52805	}
53579		- case 18446744073709548438LLU: // 99999999NV'''''''''''''''
	52806	+ case 18446744073709548485LLU: // 99999999OE'''''''''''''''
53580	52807	{
53581		- state.addr = 18446744073709548439LLU; // 99999999NW'''''''''''''''
	52808	+ state.addr = 18446744073709548486LLU; // 99999999OF'''''''''''''''
53582	52809	break;
53583	52810	}
53584		- case 18446744073709548439LLU: // 99999999NW'''''''''''''''
	52811	+ case 18446744073709548486LLU: // 99999999OF'''''''''''''''
53585	52812	{
53586	52813	{
53587	52814	fprintf(stderr, "%s\n", "");
53588	52815	exit(-1);
53589	52816	}
53590		- state.addr = 18446744073709548444LLU; // 99999999Na'''''''''''''''
	52817	+ state.addr = 18446744073709548491LLU; // 99999999OK'''''''''''''''
53591	52818	break;
53592	52819	}
53593		- case 18446744073709548444LLU: // 99999999Na'''''''''''''''
	52820	+ case 18446744073709548491LLU: // 99999999OK'''''''''''''''
53594	52821	{
53595		- state.addr = 18446744073709548437LLU; // 99999999NU'''''''''''''''
	52822	+ state.addr = 18446744073709548484LLU; // 99999999OD'''''''''''''''
53596	52823	break;
53597	52824	}
53598		- case 18446744073709548437LLU: // 99999999NU'''''''''''''''
	52825	+ case 18446744073709548484LLU: // 99999999OD'''''''''''''''
53599	52826	{
53600	52827	if(!/resultargs/*LOCAL_ACCESS(heap.data, 23LLU, 17LLU))
53601	52828	{
53602		- state.addr = 18446744073709548436LLU; // 99999999NT'''''''''''''''
	52829	+ state.addr = 18446744073709548483LLU; // 99999999OC'''''''''''''''
53603	52830	break;
53604	52831	}
53605	52832	{

		@@ -53612,7 +52839,7 @@
53612	52839	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53613	52840	}
53614	52841	// ACCUMULATE ARGUMENTS - END
53615		- uint64_t return_to = 18446744073709548434LLU;
	52842	+ uint64_t return_to = 18446744073709548481LLU;
53616	52843	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53617	52844	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53618	52845	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53621,12 +52848,12 @@
53621	52848	state.addr = 819847183515949359LLU; // reportinit
53622	52849	break;
53623	52850	}
53624		- case 18446744073709548434LLU: // 99999999NR'''''''''''''''
	52851	+ case 18446744073709548481LLU: // 99999999OA'''''''''''''''
53625	52852	{
53626		- state.addr = 18446744073709548435LLU; // 99999999NS'''''''''''''''
	52853	+ state.addr = 18446744073709548482LLU; // 99999999OB'''''''''''''''
53627	52854	break;
53628	52855	}
53629		- case 18446744073709548435LLU: // 99999999NS'''''''''''''''
	52856	+ case 18446744073709548482LLU: // 99999999OB'''''''''''''''
53630	52857	{
53631	52858	fprintf(stderr, "%s", "cannot call function ");
53632	52859	printid(stderr, /callee_id_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 24LLU, 10LLU)));

		@@ -53644,7 +52871,7 @@
53644	52871	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53645	52872	}
53646	52873	// ACCUMULATE ARGUMENTS - END
53647		- uint64_t return_to = 18446744073709548433LLU;
	52874	+ uint64_t return_to = 18446744073709548480LLU;
53648	52875	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53649	52876	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53650	52877	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53653,13 +52880,13 @@
53653	52880	state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
53654	52881	break;
53655	52882	}
53656		- case 18446744073709548433LLU: // 99999999NQ'''''''''''''''
	52883	+ case 18446744073709548480LLU: // 99999999O_'''''''''''''''
53657	52884	{
53658	52885	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dummy_____ at 24
53659		- state.addr = 18446744073709548437LLU; // 99999999NU'''''''''''''''
	52886	+ state.addr = 18446744073709548484LLU; // 99999999OD'''''''''''''''
53660	52887	break;
53661	52888	}
53662		- case 18446744073709548436LLU: // 99999999NT'''''''''''''''
	52889	+ case 18446744073709548483LLU: // 99999999OC'''''''''''''''
53663	52890	{
53664	52891	// variable u64 outofheap_ goes out of scope
53665	52892	// emitted destructur for type u64

		@@ -53667,10 +52894,10 @@
53667	52894	// variable u64 sizeonheap goes out of scope
53668	52895	// emitted destructur for type u64
53669	52896	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 22
53670		- state.addr = 18446744073709548448LLU; // 99999999Ne'''''''''''''''
	52897	+ state.addr = 18446744073709548495LLU; // 99999999OO'''''''''''''''
53671	52898	break;
53672	52899	}
53673		- case 18446744073709548448LLU: // 99999999Ne'''''''''''''''
	52900	+ case 18446744073709548495LLU: // 99999999OO'''''''''''''''
53674	52901	{
53675	52902	list_size(heap.data, /calleeargs/LOCAL_ACCESS(heap.data, 21LLU, 18LLU), &/calleeacnt/LOCAL_ACCESS(heap.data, 21LLU, 20LLU));
53676	52903	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -53695,7 +52922,7 @@
53695	52922	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53696	52923	}
53697	52924	// ACCUMULATE ARGUMENTS - END
53698		- uint64_t return_to = 18446744073709548431LLU;
	52925	+ uint64_t return_to = 18446744073709548478LLU;
53699	52926	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
53700	52927	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53701	52928	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53704,12 +52931,12 @@
53704	52931	state.addr = 517555565476072800LLU; // assertsize
53705	52932	break;
53706	52933	}
53707		- case 18446744073709548431LLU: // 99999999NO'''''''''''''''
	52934	+ case 18446744073709548478LLU: // 99999999N8'''''''''''''''
53708	52935	{
53709		- state.addr = 18446744073709548432LLU; // 99999999NP'''''''''''''''
	52936	+ state.addr = 18446744073709548479LLU; // 99999999N9'''''''''''''''
53710	52937	break;
53711	52938	}
53712		- case 18446744073709548432LLU: // 99999999NP'''''''''''''''
	52939	+ case 18446744073709548479LLU: // 99999999N9'''''''''''''''
53713	52940	{
53714	52941	{
53715	52942	uint64_t arg = /remainheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 15LLU));

		@@ -53721,7 +52948,7 @@
53721	52948	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53722	52949	}
53723	52950	// ACCUMULATE ARGUMENTS - END
53724		- uint64_t return_to = 18446744073709548429LLU;
	52951	+ uint64_t return_to = 18446744073709548476LLU;
53725	52952	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53726	52953	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53727	52954	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53730,12 +52957,12 @@
53730	52957	state.addr = 839519719621918720LLU; // skipws____
53731	52958	break;
53732	52959	}
53733		- case 18446744073709548429LLU: // 99999999NM'''''''''''''''
	52960	+ case 18446744073709548476LLU: // 99999999N6'''''''''''''''
53734	52961	{
53735		- state.addr = 18446744073709548430LLU; // 99999999NN'''''''''''''''
	52962	+ state.addr = 18446744073709548477LLU; // 99999999N7'''''''''''''''
53736	52963	break;
53737	52964	}
53738		- case 18446744073709548430LLU: // 99999999NN'''''''''''''''
	52965	+ case 18446744073709548477LLU: // 99999999N7'''''''''''''''
53739	52966	{
53740	52967	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
53741	52968	{

		@@ -53758,7 +52985,7 @@
53758	52985	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53759	52986	}
53760	52987	// ACCUMULATE ARGUMENTS - END
53761		- uint64_t return_to = 18446744073709548426LLU;
	52988	+ uint64_t return_to = 18446744073709548473LLU;
53762	52989	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53763	52990	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53764	52991	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53767,12 +52994,12 @@
53767	52994	state.addr = 517555828430075934LLU; // assign_dec
53768	52995	break;
53769	52996	}
53770		- case 18446744073709548426LLU: // 99999999NJ'''''''''''''''
	52997	+ case 18446744073709548473LLU: // 99999999N3'''''''''''''''
53771	52998	{
53772		- state.addr = 18446744073709548427LLU; // 99999999NK'''''''''''''''
	52999	+ state.addr = 18446744073709548474LLU; // 99999999N4'''''''''''''''
53773	53000	break;
53774	53001	}
53775		- case 18446744073709548427LLU: // 99999999NK'''''''''''''''
	53002	+ case 18446744073709548474LLU: // 99999999N4'''''''''''''''
53776	53003	{
53777	53004	// ACCUMULATE ARGUMENTS - BEGIN
53778	53005	{

		@@ -53792,7 +53019,7 @@
53792	53019	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53793	53020	}
53794	53021	// ACCUMULATE ARGUMENTS - END
53795		- uint64_t return_to = 18446744073709548424LLU;
	53022	+ uint64_t return_to = 18446744073709548471LLU;
53796	53023	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53797	53024	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53798	53025	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53801,12 +53028,12 @@
53801	53028	state.addr = 548487490190330432LLU; // callbegin_
53802	53029	break;
53803	53030	}
53804		- case 18446744073709548424LLU: // 99999999NH'''''''''''''''
	53031	+ case 18446744073709548471LLU: // 99999999N1'''''''''''''''
53805	53032	{
53806		- state.addr = 18446744073709548425LLU; // 99999999NI'''''''''''''''
	53033	+ state.addr = 18446744073709548472LLU; // 99999999N2'''''''''''''''
53807	53034	break;
53808	53035	}
53809		- case 18446744073709548425LLU: // 99999999NI'''''''''''''''
	53036	+ case 18446744073709548472LLU: // 99999999N2'''''''''''''''
53810	53037	{
53811	53038	{
53812	53039	uint64_t arg = /calleeacnt/*LOCAL_ACCESS(heap.data, 24LLU, 20LLU);

		@@ -53824,10 +53051,10 @@
53824	53051	uint64_t arg = 0;
53825	53052	LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
53826	53053	}
53827		- state.addr = 18446744073709548422LLU; // 99999999NF'''''''''''''''
	53054	+ state.addr = 18446744073709548469LLU; // 99999999Nz'''''''''''''''
53828	53055	break;
53829	53056	}
53830		- case 18446744073709548422LLU: // 99999999NF'''''''''''''''
	53057	+ case 18446744073709548469LLU: // 99999999Nz'''''''''''''''
53831	53058	{
53832	53059	if(!*LOCAL_ACCESS(heap.data, 28LLU, 26LLU))
53833	53060	{

		@@ -53834,7 +53061,7 @@
53834	53061	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 28
53835	53062	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
53836	53063	{
53837		- state.addr = 18446744073709548421LLU; // 99999999NE'''''''''''''''
	53064	+ state.addr = 18446744073709548468LLU; // 99999999Ny'''''''''''''''
53838	53065	break;
53839	53066	}
53840	53067	}

		@@ -53841,19 +53068,19 @@
53841	53068	/direct/LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = (LOCAL_ACCESS(heap.data, 28LLU, 26LLU) << 1) + 1LLU;
53842	53069	LOCAL_ACCESS(heap.data, 28LLU, 26LLU) = heap.data[LOCAL_ACCESS(heap.data, 28LLU, 26LLU)].elem0;
53843	53070	--/arg_offset/*LOCAL_ACCESS(heap.data, 28LLU, 24LLU);
53844		- state.addr = /first_____/*LOCAL_ACCESS(heap.data, 28LLU, 25LLU) ? 18446744073709548420LLU : 18446744073709548419LLU;
	53071	+ state.addr = /first_____/*LOCAL_ACCESS(heap.data, 28LLU, 25LLU) ? 18446744073709548467LLU : 18446744073709548466LLU;
53845	53072	break;
53846	53073	}
53847		- case 18446744073709548420LLU: // 99999999ND'''''''''''''''
	53074	+ case 18446744073709548467LLU: // 99999999Nx'''''''''''''''
53848	53075	{
53849	53076	*LOCAL_ACCESS(heap.data, 28LLU, 25LLU) = 0LLU;
53850	53077
53851	53078	heap.availilable_size_for_dynamic_objects += 0LLU;
53852	53079	heap.availilable_size_for_dynamic_objects += 0LLU;
53853		- state.addr = 18446744073709548418LLU; // 99999999NB'''''''''''''''
	53080	+ state.addr = 18446744073709548465LLU; // 99999999Nv'''''''''''''''
53854	53081	break;
53855	53082	}
53856		- case 18446744073709548419LLU: // 99999999NC'''''''''''''''
	53083	+ case 18446744073709548466LLU: // 99999999Nw'''''''''''''''
53857	53084	{
53858	53085	// ACCUMULATE ARGUMENTS - BEGIN
53859	53086	{

		@@ -53861,7 +53088,7 @@
53861	53088	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53862	53089	}
53863	53090	// ACCUMULATE ARGUMENTS - END
53864		- uint64_t return_to = 18446744073709548416LLU;
	53091	+ uint64_t return_to = 18446744073709548463LLU;
53865	53092	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53866	53093	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53867	53094	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53870,18 +53097,18 @@
53870	53097	state.addr = 839519719621918720LLU; // skipws____
53871	53098	break;
53872	53099	}
53873		- case 18446744073709548416LLU: // 99999999N_'''''''''''''''
	53100	+ case 18446744073709548463LLU: // 99999999Nt'''''''''''''''
53874	53101	{
53875		- state.addr = 18446744073709548417LLU; // 99999999NA'''''''''''''''
	53102	+ state.addr = 18446744073709548464LLU; // 99999999Nu'''''''''''''''
53876	53103	break;
53877	53104	}
53878		- case 18446744073709548417LLU: // 99999999NA'''''''''''''''
	53105	+ case 18446744073709548464LLU: // 99999999Nu'''''''''''''''
53879	53106	{
53880	53107	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 28LLU, 11LLU)));
53881		- state.addr = 18446744073709548418LLU; // 99999999NB'''''''''''''''
	53108	+ state.addr = 18446744073709548465LLU; // 99999999Nv'''''''''''''''
53882	53109	break;
53883	53110	}
53884		- case 18446744073709548418LLU: // 99999999NB'''''''''''''''
	53111	+ case 18446744073709548465LLU: // 99999999Nv'''''''''''''''
53885	53112	{
53886	53113	{
53887	53114	uint64_t arg = 0LLU;

		@@ -53897,7 +53124,7 @@
53897	53124	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53898	53125	}
53899	53126	// ACCUMULATE ARGUMENTS - END
53900		- uint64_t return_to = 18446744073709548414LLU;
	53127	+ uint64_t return_to = 18446744073709548461LLU;
53901	53128	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53902	53129	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53903	53130	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53906,12 +53133,12 @@
53906	53133	state.addr = 367395560426147840LLU; // TYPECOPY__
53907	53134	break;
53908	53135	}
53909		- case 18446744073709548414LLU: // 99999999M8'''''''''''''''
	53136	+ case 18446744073709548461LLU: // 99999999Nr'''''''''''''''
53910	53137	{
53911		- state.addr = 18446744073709548415LLU; // 99999999M9'''''''''''''''
	53138	+ state.addr = 18446744073709548462LLU; // 99999999Ns'''''''''''''''
53912	53139	break;
53913	53140	}
53914		- case 18446744073709548415LLU: // 99999999M9'''''''''''''''
	53141	+ case 18446744073709548462LLU: // 99999999Ns'''''''''''''''
53915	53142	{
53916	53143	// ACCUMULATE ARGUMENTS - BEGIN
53917	53144	{

		@@ -53919,7 +53146,7 @@
53919	53146	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53920	53147	}
53921	53148	// ACCUMULATE ARGUMENTS - END
53922		- uint64_t return_to = 18446744073709548412LLU;
	53149	+ uint64_t return_to = 18446744073709548459LLU;
53923	53150	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53924	53151	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53925	53152	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53928,12 +53155,12 @@
53928	53155	state.addr = 839519719621918720LLU; // skipws____
53929	53156	break;
53930	53157	}
53931		- case 18446744073709548412LLU: // 99999999M6'''''''''''''''
	53158	+ case 18446744073709548459LLU: // 99999999Np'''''''''''''''
53932	53159	{
53933		- state.addr = 18446744073709548413LLU; // 99999999M7'''''''''''''''
	53160	+ state.addr = 18446744073709548460LLU; // 99999999Nq'''''''''''''''
53934	53161	break;
53935	53162	}
53936		- case 18446744073709548413LLU: // 99999999M7'''''''''''''''
	53163	+ case 18446744073709548460LLU: // 99999999Nq'''''''''''''''
53937	53164	{
53938	53165	{
53939	53166	uint64_t arg = 0LLU;

		@@ -53949,7 +53176,7 @@
53949	53176	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53950	53177	}
53951	53178	// ACCUMULATE ARGUMENTS - END
53952		- uint64_t return_to = 18446744073709548410LLU;
	53179	+ uint64_t return_to = 18446744073709548457LLU;
53953	53180	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53954	53181	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53955	53182	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53958,27 +53185,27 @@
53958	53185	state.addr = 661592067397386240LLU; // isalpha___
53959	53186	break;
53960	53187	}
53961		- case 18446744073709548410LLU: // 99999999M4'''''''''''''''
	53188	+ case 18446744073709548457LLU: // 99999999Nn'''''''''''''''
53962	53189	{
53963		- state.addr = 18446744073709548411LLU; // 99999999M5'''''''''''''''
	53190	+ state.addr = 18446744073709548458LLU; // 99999999No'''''''''''''''
53964	53191	break;
53965	53192	}
53966		- case 18446744073709548411LLU: // 99999999M5'''''''''''''''
	53193	+ case 18446744073709548458LLU: // 99999999No'''''''''''''''
53967	53194	{
53968		- state.addr = /argid_____/*LOCAL_ACCESS(heap.data, 30LLU, 29LLU) ? 18446744073709548409LLU : 18446744073709548408LLU;
	53195	+ state.addr = /argid_____/*LOCAL_ACCESS(heap.data, 30LLU, 29LLU) ? 18446744073709548456LLU : 18446744073709548455LLU;
53969	53196	break;
53970	53197	}
53971		- case 18446744073709548409LLU: // 99999999M3'''''''''''''''
	53198	+ case 18446744073709548456LLU: // 99999999Nm'''''''''''''''
53972	53199	{
53973	53200	/argid_____/LOCAL_ACCESS(heap.data, 30LLU, 29LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 30LLU, 11LLU)));
53974		- state.addr = 18446744073709548408LLU; // 99999999M2'''''''''''''''
	53201	+ state.addr = 18446744073709548455LLU; // 99999999Nl'''''''''''''''
53975	53202	break;
53976	53203	}
53977		- case 18446744073709548408LLU: // 99999999M2'''''''''''''''
	53204	+ case 18446744073709548455LLU: // 99999999Nl'''''''''''''''
53978	53205	{
53979	53206	// ACCUMULATE ARGUMENTS - BEGIN
53980	53207	// ACCUMULATE ARGUMENTS - END
53981		- uint64_t return_to = 18446744073709548406LLU;
	53208	+ uint64_t return_to = 18446744073709548453LLU;
53982	53209	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
53983	53210	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53984	53211	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53987,12 +53214,12 @@
53987	53214	state.addr = 517221998735392768LLU; // argopen___
53988	53215	break;
53989	53216	}
53990		- case 18446744073709548406LLU: // 99999999M0'''''''''''''''
	53217	+ case 18446744073709548453LLU: // 99999999Nj'''''''''''''''
53991	53218	{
53992		- state.addr = 18446744073709548407LLU; // 99999999M1'''''''''''''''
	53219	+ state.addr = 18446744073709548454LLU; // 99999999Nk'''''''''''''''
53993	53220	break;
53994	53221	}
53995		- case 18446744073709548407LLU: // 99999999M1'''''''''''''''
	53222	+ case 18446744073709548454LLU: // 99999999Nk'''''''''''''''
53996	53223	{
53997	53224	// ACCUMULATE ARGUMENTS - BEGIN
53998	53225	{

		@@ -54080,7 +53307,7 @@
54080	53307	LOCAL_PUSH_MOVE(&heap, 20LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54081	53308	}
54082	53309	// ACCUMULATE ARGUMENTS - END
54083		- uint64_t return_to = 18446744073709548404LLU;
	53310	+ uint64_t return_to = 18446744073709548451LLU;
54084	53311	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/address of closure-in-construction*/, 0));
54085	53312	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54086	53313	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 21LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54089,12 +53316,12 @@
54089	53316	state.addr = 787472320226131968LLU; // procarg___
54090	53317	break;
54091	53318	}
54092		- case 18446744073709548404LLU: // 99999999My'''''''''''''''
	53319	+ case 18446744073709548451LLU: // 99999999Nh'''''''''''''''
54093	53320	{
54094		- state.addr = 18446744073709548405LLU; // 99999999Mz'''''''''''''''
	53321	+ state.addr = 18446744073709548452LLU; // 99999999Ni'''''''''''''''
54095	53322	break;
54096	53323	}
54097		- case 18446744073709548405LLU: // 99999999Mz'''''''''''''''
	53324	+ case 18446744073709548452LLU: // 99999999Ni'''''''''''''''
54098	53325	{
54099	53326	// ACCUMULATE ARGUMENTS - BEGIN
54100	53327	{

		@@ -54118,7 +53345,7 @@
54118	53345	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54119	53346	}
54120	53347	// ACCUMULATE ARGUMENTS - END
54121		- uint64_t return_to = 18446744073709548402LLU;
	53348	+ uint64_t return_to = 18446744073709548449LLU;
54122	53349	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
54123	53350	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54124	53351	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54127,12 +53354,12 @@
54127	53354	state.addr = 517221169975918592LLU; // argclose__
54128	53355	break;
54129	53356	}
54130		- case 18446744073709548402LLU: // 99999999Mw'''''''''''''''
	53357	+ case 18446744073709548449LLU: // 99999999Nf'''''''''''''''
54131	53358	{
54132		- state.addr = 18446744073709548403LLU; // 99999999Mx'''''''''''''''
	53359	+ state.addr = 18446744073709548450LLU; // 99999999Ng'''''''''''''''
54133	53360	break;
54134	53361	}
54135		- case 18446744073709548403LLU: // 99999999Mx'''''''''''''''
	53362	+ case 18446744073709548450LLU: // 99999999Ng'''''''''''''''
54136	53363	{
54137	53364	// variable u64 argid_____ goes out of scope
54138	53365	// emitted destructur for type u64

		@@ -54145,7 +53372,7 @@
54145	53372	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54146	53373	}
54147	53374	// ACCUMULATE ARGUMENTS - END
54148		- uint64_t return_to = 18446744073709548401LLU;
	53375	+ uint64_t return_to = 18446744073709548448LLU;
54149	53376	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54150	53377	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54151	53378	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54154,23 +53381,23 @@
54154	53381	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
54155	53382	break;
54156	53383	}
54157		- case 18446744073709548401LLU: // 99999999Mv'''''''''''''''
	53384	+ case 18446744073709548448LLU: // 99999999Ne'''''''''''''''
54158	53385	{
54159	53386	(void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typepar___ at 29
54160	53387	// parameter-reference pardef____ par_______ goes out of scope
54161	53388	// parameter list<pardef____> calleeargs goes out of scope
54162		- state.addr = 18446744073709548422LLU; // 99999999NF'''''''''''''''
	53389	+ state.addr = 18446744073709548469LLU; // 99999999Nz'''''''''''''''
54163	53390	break;
54164	53391	}
54165		- case 18446744073709548421LLU: // 99999999NE'''''''''''''''
	53392	+ case 18446744073709548468LLU: // 99999999Ny'''''''''''''''
54166	53393	{
54167	53394	// variable u64 first_____ goes out of scope
54168	53395	// emitted destructur for type u64
54169	53396	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference first_____ at 26
54170		- state.addr = 18446744073709548423LLU; // 99999999NG'''''''''''''''
	53397	+ state.addr = 18446744073709548470LLU; // 99999999N0'''''''''''''''
54171	53398	break;
54172	53399	}
54173		- case 18446744073709548423LLU: // 99999999NG'''''''''''''''
	53400	+ case 18446744073709548470LLU: // 99999999N0'''''''''''''''
54174	53401	{
54175	53402	// ACCUMULATE ARGUMENTS - BEGIN
54176	53403	{

		@@ -54194,7 +53421,7 @@
54194	53421	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54195	53422	}
54196	53423	// ACCUMULATE ARGUMENTS - END
54197		- uint64_t return_to = 18446744073709548399LLU;
	53424	+ uint64_t return_to = 18446744073709548446LLU;
54198	53425	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
54199	53426	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54200	53427	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54203,12 +53430,12 @@
54203	53430	state.addr = 548487493561614336LLU; // callend___
54204	53431	break;
54205	53432	}
54206		- case 18446744073709548399LLU: // 99999999Mt'''''''''''''''
	53433	+ case 18446744073709548446LLU: // 99999999Nc'''''''''''''''
54207	53434	{
54208		- state.addr = 18446744073709548400LLU; // 99999999Mu'''''''''''''''
	53435	+ state.addr = 18446744073709548447LLU; // 99999999Nd'''''''''''''''
54209	53436	break;
54210	53437	}
54211		- case 18446744073709548400LLU: // 99999999Mu'''''''''''''''
	53438	+ case 18446744073709548447LLU: // 99999999Nd'''''''''''''''
54212	53439	{
54213	53440	// variable u64 arg_offset goes out of scope
54214	53441	// emitted destructur for type u64

		@@ -54219,10 +53446,10 @@
54219	53446	// variable u64 callrs____ goes out of scope
54220	53447	// emitted destructur for type u64
54221	53448	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference callrs____ at 23
54222		- state.addr = 18446744073709548428LLU; // 99999999NL'''''''''''''''
	53449	+ state.addr = 18446744073709548475LLU; // 99999999N5'''''''''''''''
54223	53450	break;
54224	53451	}
54225		- case 18446744073709548428LLU: // 99999999NL'''''''''''''''
	53452	+ case 18446744073709548475LLU: // 99999999N5'''''''''''''''
54226	53453	{
54227	53454	// ACCUMULATE ARGUMENTS - BEGIN
54228	53455	{

		@@ -54230,7 +53457,7 @@
54230	53457	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54231	53458	}
54232	53459	// ACCUMULATE ARGUMENTS - END
54233		- uint64_t return_to = 18446744073709548397LLU;
	53460	+ uint64_t return_to = 18446744073709548444LLU;
54234	53461	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54235	53462	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54236	53463	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54239,12 +53466,12 @@
54239	53466	state.addr = 839519719621918720LLU; // skipws____
54240	53467	break;
54241	53468	}
54242		- case 18446744073709548397LLU: // 99999999Mr'''''''''''''''
	53469	+ case 18446744073709548444LLU: // 99999999Na'''''''''''''''
54243	53470	{
54244		- state.addr = 18446744073709548398LLU; // 99999999Ms'''''''''''''''
	53471	+ state.addr = 18446744073709548445LLU; // 99999999Nb'''''''''''''''
54245	53472	break;
54246	53473	}
54247		- case 18446744073709548398LLU: // 99999999Ms'''''''''''''''
	53474	+ case 18446744073709548445LLU: // 99999999Nb'''''''''''''''
54248	53475	{
54249	53476	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
54250	53477	{

		@@ -54305,7 +53532,7 @@
54305	53532	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54306	53533	}
54307	53534	// ACCUMULATE ARGUMENTS - END
54308		- uint64_t return_to = 18446744073709548394LLU;
	53535	+ uint64_t return_to = 18446744073709548441LLU;
54309	53536	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
54310	53537	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54311	53538	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54314,17 +53541,17 @@
54314	53541	state.addr = 533581901720365984LLU; // blockclose
54315	53542	break;
54316	53543	}
54317		- case 18446744073709548394LLU: // 99999999Mo'''''''''''''''
	53544	+ case 18446744073709548441LLU: // 99999999NY'''''''''''''''
54318	53545	{
54319		- state.addr = 18446744073709548395LLU; // 99999999Mp'''''''''''''''
	53546	+ state.addr = 18446744073709548442LLU; // 99999999NZ'''''''''''''''
54320	53547	break;
54321	53548	}
54322		- case 18446744073709548395LLU: // 99999999Mp'''''''''''''''
	53549	+ case 18446744073709548442LLU: // 99999999NZ'''''''''''''''
54323	53550	{
54324		- state.addr = /tmpresults/*LOCAL_ACCESS(heap.data, 25LLU, 16LLU) ? 18446744073709548393LLU : 18446744073709548392LLU;
	53551	+ state.addr = /tmpresults/*LOCAL_ACCESS(heap.data, 25LLU, 16LLU) ? 18446744073709548440LLU : 18446744073709548439LLU;
54325	53552	break;
54326	53553	}
54327		- case 18446744073709548393LLU: // 99999999Mn'''''''''''''''
	53554	+ case 18446744073709548440LLU: // 99999999NX'''''''''''''''
54328	53555	{
54329	53556	fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
54330	53557	{

		@@ -54331,10 +53558,10 @@
54331	53558	fprintf(stderr, "%s\n", "");
54332	53559	exit(-1);
54333	53560	}
54334		- state.addr = 18446744073709548392LLU; // 99999999Mm'''''''''''''''
	53561	+ state.addr = 18446744073709548439LLU; // 99999999NW'''''''''''''''
54335	53562	break;
54336	53563	}
54337		- case 18446744073709548392LLU: // 99999999Mm'''''''''''''''
	53564	+ case 18446744073709548439LLU: // 99999999NW'''''''''''''''
54338	53565	{
54339	53566	{
54340	53567	uint64_t arg = 0LLU;

		@@ -54341,10 +53568,10 @@
54341	53568	LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/address of current closure/, &arg);
54342	53569	}
54343	53570	/buf_______/LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 26LLU, 13LLU)) != /ds________/LOCAL_ACCESS(heap.data, 26LLU, 22LLU);
54344		- state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548391LLU : 18446744073709548390LLU;
	53571	+ state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548438LLU : 18446744073709548437LLU;
54345	53572	break;
54346	53573	}
54347		- case 18446744073709548391LLU: // 99999999Ml'''''''''''''''
	53574	+ case 18446744073709548438LLU: // 99999999NV'''''''''''''''
54348	53575	{
54349	53576	fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
54350	53577	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54353,7 +53580,7 @@
54353	53580	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54354	53581	}
54355	53582	// ACCUMULATE ARGUMENTS - END
54356		- uint64_t return_to = 18446744073709548388LLU;
	53583	+ uint64_t return_to = 18446744073709548435LLU;
54357	53584	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54358	53585	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54359	53586	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54362,12 +53589,12 @@
54362	53589	state.addr = 819847183517274112LLU; // reportnr__
54363	53590	break;
54364	53591	}
54365		- case 18446744073709548388LLU: // 99999999Mi'''''''''''''''
	53592	+ case 18446744073709548435LLU: // 99999999NS'''''''''''''''
54366	53593	{
54367		- state.addr = 18446744073709548389LLU; // 99999999Mj'''''''''''''''
	53594	+ state.addr = 18446744073709548436LLU; // 99999999NT'''''''''''''''
54368	53595	break;
54369	53596	}
54370		- case 18446744073709548389LLU: // 99999999Mj'''''''''''''''
	53597	+ case 18446744073709548436LLU: // 99999999NT'''''''''''''''
54371	53598	{
54372	53599	fprintf(stderr, "%s", " != ");
54373	53600	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54376,7 +53603,7 @@
54376	53603	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54377	53604	}
54378	53605	// ACCUMULATE ARGUMENTS - END
54379		- uint64_t return_to = 18446744073709548386LLU;
	53606	+ uint64_t return_to = 18446744073709548433LLU;
54380	53607	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54381	53608	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54382	53609	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54385,27 +53612,27 @@
54385	53612	state.addr = 819847183517274112LLU; // reportnr__
54386	53613	break;
54387	53614	}
54388		- case 18446744073709548386LLU: // 99999999Mg'''''''''''''''
	53615	+ case 18446744073709548433LLU: // 99999999NQ'''''''''''''''
54389	53616	{
54390		- state.addr = 18446744073709548387LLU; // 99999999Mh'''''''''''''''
	53617	+ state.addr = 18446744073709548434LLU; // 99999999NR'''''''''''''''
54391	53618	break;
54392	53619	}
54393		- case 18446744073709548387LLU: // 99999999Mh'''''''''''''''
	53620	+ case 18446744073709548434LLU: // 99999999NR'''''''''''''''
54394	53621	{
54395	53622	{
54396	53623	fprintf(stderr, "%s\n", "");
54397	53624	exit(-1);
54398	53625	}
54399		- state.addr = 18446744073709548390LLU; // 99999999Mk'''''''''''''''
	53626	+ state.addr = 18446744073709548437LLU; // 99999999NU'''''''''''''''
54400	53627	break;
54401	53628	}
54402		- case 18446744073709548390LLU: // 99999999Mk'''''''''''''''
	53629	+ case 18446744073709548437LLU: // 99999999NU'''''''''''''''
54403	53630	{
54404	53631	/buf_______/LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 26LLU, 14LLU)) != /rs________/LOCAL_ACCESS(heap.data, 26LLU, 23LLU);
54405		- state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548385LLU : 18446744073709548384LLU;
	53632	+ state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548432LLU : 18446744073709548431LLU;
54406	53633	break;
54407	53634	}
54408		- case 18446744073709548385LLU: // 99999999Mf'''''''''''''''
	53635	+ case 18446744073709548432LLU: // 99999999NP'''''''''''''''
54409	53636	{
54410	53637	fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
54411	53638	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54414,7 +53641,7 @@
54414	53641	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54415	53642	}
54416	53643	// ACCUMULATE ARGUMENTS - END
54417		- uint64_t return_to = 18446744073709548382LLU;
	53644	+ uint64_t return_to = 18446744073709548429LLU;
54418	53645	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54419	53646	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54420	53647	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54423,12 +53650,12 @@
54423	53650	state.addr = 819847183517274112LLU; // reportnr__
54424	53651	break;
54425	53652	}
54426		- case 18446744073709548382LLU: // 99999999Mc'''''''''''''''
	53653	+ case 18446744073709548429LLU: // 99999999NM'''''''''''''''
54427	53654	{
54428		- state.addr = 18446744073709548383LLU; // 99999999Md'''''''''''''''
	53655	+ state.addr = 18446744073709548430LLU; // 99999999NN'''''''''''''''
54429	53656	break;
54430	53657	}
54431		- case 18446744073709548383LLU: // 99999999Md'''''''''''''''
	53658	+ case 18446744073709548430LLU: // 99999999NN'''''''''''''''
54432	53659	{
54433	53660	fprintf(stderr, "%s", " != ");
54434	53661	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54437,7 +53664,7 @@
54437	53664	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54438	53665	}
54439	53666	// ACCUMULATE ARGUMENTS - END
54440		- uint64_t return_to = 18446744073709548380LLU;
	53667	+ uint64_t return_to = 18446744073709548427LLU;
54441	53668	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54442	53669	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54443	53670	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54446,27 +53673,27 @@
54446	53673	state.addr = 819847183517274112LLU; // reportnr__
54447	53674	break;
54448	53675	}
54449		- case 18446744073709548380LLU: // 99999999Ma'''''''''''''''
	53676	+ case 18446744073709548427LLU: // 99999999NK'''''''''''''''
54450	53677	{
54451		- state.addr = 18446744073709548381LLU; // 99999999Mb'''''''''''''''
	53678	+ state.addr = 18446744073709548428LLU; // 99999999NL'''''''''''''''
54452	53679	break;
54453	53680	}
54454		- case 18446744073709548381LLU: // 99999999Mb'''''''''''''''
	53681	+ case 18446744073709548428LLU: // 99999999NL'''''''''''''''
54455	53682	{
54456	53683	{
54457	53684	fprintf(stderr, "%s\n", "");
54458	53685	exit(-1);
54459	53686	}
54460		- state.addr = 18446744073709548384LLU; // 99999999Me'''''''''''''''
	53687	+ state.addr = 18446744073709548431LLU; // 99999999NO'''''''''''''''
54461	53688	break;
54462	53689	}
54463		- case 18446744073709548384LLU: // 99999999Me'''''''''''''''
	53690	+ case 18446744073709548431LLU: // 99999999NO'''''''''''''''
54464	53691	{
54465	53692	/buf_______/LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = /remainheap/LOCAL_ACCESS(heap.data, 26LLU, 21LLU) != /rh________/*LOCAL_ACCESS(heap.data, 26LLU, 24LLU);
54466		- state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548379LLU : 18446744073709548378LLU;
	53693	+ state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709548426LLU : 18446744073709548425LLU;
54467	53694	break;
54468	53695	}
54469		- case 18446744073709548379LLU: // 99999999M$'''''''''''''''
	53696	+ case 18446744073709548426LLU: // 99999999NJ'''''''''''''''
54470	53697	{
54471	53698	// ACCUMULATE ARGUMENTS - BEGIN
54472	53699	{

		@@ -54474,7 +53701,7 @@
54474	53701	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54475	53702	}
54476	53703	// ACCUMULATE ARGUMENTS - END
54477		- uint64_t return_to = 18446744073709548376LLU;
	53704	+ uint64_t return_to = 18446744073709548423LLU;
54478	53705	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54479	53706	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54480	53707	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54483,12 +53710,12 @@
54483	53710	state.addr = 819847183515949359LLU; // reportinit
54484	53711	break;
54485	53712	}
54486		- case 18446744073709548376LLU: // 99999999MX'''''''''''''''
	53713	+ case 18446744073709548423LLU: // 99999999NG'''''''''''''''
54487	53714	{
54488		- state.addr = 18446744073709548377LLU; // 99999999MY'''''''''''''''
	53715	+ state.addr = 18446744073709548424LLU; // 99999999NH'''''''''''''''
54489	53716	break;
54490	53717	}
54491		- case 18446744073709548377LLU: // 99999999MY'''''''''''''''
	53718	+ case 18446744073709548424LLU: // 99999999NH'''''''''''''''
54492	53719	{
54493	53720	fprintf(stderr, "%s", "remainheap mismatch ");
54494	53721	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54497,7 +53724,7 @@
54497	53724	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54498	53725	}
54499	53726	// ACCUMULATE ARGUMENTS - END
54500		- uint64_t return_to = 18446744073709548374LLU;
	53727	+ uint64_t return_to = 18446744073709548421LLU;
54501	53728	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54502	53729	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54503	53730	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54506,12 +53733,12 @@
54506	53733	state.addr = 819847183517274112LLU; // reportnr__
54507	53734	break;
54508	53735	}
54509		- case 18446744073709548374LLU: // 99999999MV'''''''''''''''
	53736	+ case 18446744073709548421LLU: // 99999999NE'''''''''''''''
54510	53737	{
54511		- state.addr = 18446744073709548375LLU; // 99999999MW'''''''''''''''
	53738	+ state.addr = 18446744073709548422LLU; // 99999999NF'''''''''''''''
54512	53739	break;
54513	53740	}
54514		- case 18446744073709548375LLU: // 99999999MW'''''''''''''''
	53741	+ case 18446744073709548422LLU: // 99999999NF'''''''''''''''
54515	53742	{
54516	53743	fprintf(stderr, "%s", " != ");
54517	53744	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54520,7 +53747,7 @@
54520	53747	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54521	53748	}
54522	53749	// ACCUMULATE ARGUMENTS - END
54523		- uint64_t return_to = 18446744073709548372LLU;
	53750	+ uint64_t return_to = 18446744073709548419LLU;
54524	53751	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54525	53752	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54526	53753	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54529,18 +53756,18 @@
54529	53756	state.addr = 819847183517274112LLU; // reportnr__
54530	53757	break;
54531	53758	}
54532		- case 18446744073709548372LLU: // 99999999MT'''''''''''''''
	53759	+ case 18446744073709548419LLU: // 99999999NC'''''''''''''''
54533	53760	{
54534		- state.addr = 18446744073709548373LLU; // 99999999MU'''''''''''''''
	53761	+ state.addr = 18446744073709548420LLU; // 99999999ND'''''''''''''''
54535	53762	break;
54536	53763	}
54537		- case 18446744073709548373LLU: // 99999999MU'''''''''''''''
	53764	+ case 18446744073709548420LLU: // 99999999ND'''''''''''''''
54538	53765	{
54539	53766	fprintf(stderr, "%s", " SHOULD be due to temporary constructor\n");
54540		- state.addr = 18446744073709548378LLU; // 99999999MZ'''''''''''''''
	53767	+ state.addr = 18446744073709548425LLU; // 99999999NI'''''''''''''''
54541	53768	break;
54542	53769	}
54543		- case 18446744073709548378LLU: // 99999999MZ'''''''''''''''
	53770	+ case 18446744073709548425LLU: // 99999999NI'''''''''''''''
54544	53771	{
54545	53772	// variable u64 buf_______ goes out of scope
54546	53773	// emitted destructur for type u64

		@@ -54554,10 +53781,10 @@
54554	53781	// variable u64 ds________ goes out of scope
54555	53782	// emitted destructur for type u64
54556	53783	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ds________ at 23
54557		- state.addr = 18446744073709548396LLU; // 99999999Mq'''''''''''''''
	53784	+ state.addr = 18446744073709548443LLU; // 99999999N$'''''''''''''''
54558	53785	break;
54559	53786	}
54560		- case 18446744073709548396LLU: // 99999999Mq'''''''''''''''
	53787	+ case 18446744073709548443LLU: // 99999999N$'''''''''''''''
54561	53788	{
54562	53789	// variable u64 remainheap goes out of scope
54563	53790	// emitted destructur for type u64

		@@ -54570,14 +53797,14 @@
54570	53797	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleesize at 20
54571	53798	// variable list<pardef____> calleeargs goes out of scope
54572	53799	// emitted destructur for type list<pardef____>
54573		- state.addr = 18446744073709548370LLU; // 99999999MR'''''''''''''''
	53800	+ state.addr = 18446744073709548417LLU; // 99999999NA'''''''''''''''
54574	53801	break;
54575	53802	}
54576		- case 18446744073709548370LLU: // 99999999MR'''''''''''''''
	53803	+ case 18446744073709548417LLU: // 99999999NA'''''''''''''''
54577	53804	{
54578	53805	if(!LOCAL_ACCESS(heap.data, 19LLU, 18LLU)/list*/)
54579	53806	{
54580		- state.addr = 18446744073709548371LLU; // 99999999MS'''''''''''''''
	53807	+ state.addr = 18446744073709548418LLU; // 99999999NB'''''''''''''''
54581	53808	break;
54582	53809	}
54583	53810	// temporary list-element

		@@ -54591,7 +53818,7 @@
54591	53818	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54592	53819	}
54593	53820	// ACCUMULATE ARGUMENTS - END
54594		- uint64_t return_to = 18446744073709548369LLU;
	53821	+ uint64_t return_to = 18446744073709548416LLU;
54595	53822	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54596	53823	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54597	53824	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54600,26 +53827,26 @@
54600	53827	state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
54601	53828	break;
54602	53829	}
54603		- case 18446744073709548369LLU: // 99999999MQ'''''''''''''''
	53830	+ case 18446744073709548416LLU: // 99999999N_'''''''''''''''
54604	53831	{
54605	53832	// RELEASE temporary destructor-variable
54606	53833	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
54607		- state.addr = 18446744073709548370LLU; // 99999999MR'''''''''''''''
	53834	+ state.addr = 18446744073709548417LLU; // 99999999NA'''''''''''''''
54608	53835	break;
54609	53836	}
54610		- case 18446744073709548371LLU: // 99999999MS'''''''''''''''
	53837	+ case 18446744073709548418LLU: // 99999999NB'''''''''''''''
54611	53838	{
54612	53839	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleeargs at 19
54613	53840	// variable list<resdest___> resultargs goes out of scope
54614	53841	// emitted destructur for type list<resdest___>
54615		- state.addr = 18446744073709548367LLU; // 99999999MO'''''''''''''''
	53842	+ state.addr = 18446744073709548414LLU; // 99999999M8'''''''''''''''
54616	53843	break;
54617	53844	}
54618		- case 18446744073709548367LLU: // 99999999MO'''''''''''''''
	53845	+ case 18446744073709548414LLU: // 99999999M8'''''''''''''''
54619	53846	{
54620	53847	if(!LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/list*/)
54621	53848	{
54622		- state.addr = 18446744073709548368LLU; // 99999999MP'''''''''''''''
	53849	+ state.addr = 18446744073709548415LLU; // 99999999M9'''''''''''''''
54623	53850	break;
54624	53851	}
54625	53852	// temporary list-element

		@@ -54633,7 +53860,7 @@
54633	53860	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54634	53861	}
54635	53862	// ACCUMULATE ARGUMENTS - END
54636		- uint64_t return_to = 18446744073709548366LLU;
	53863	+ uint64_t return_to = 18446744073709548413LLU;
54637	53864	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54638	53865	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54639	53866	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54642,26 +53869,26 @@
54642	53869	state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
54643	53870	break;
54644	53871	}
54645		- case 18446744073709548366LLU: // 99999999MN'''''''''''''''
	53872	+ case 18446744073709548413LLU: // 99999999M7'''''''''''''''
54646	53873	{
54647	53874	// RELEASE temporary destructor-variable
54648	53875	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
54649		- state.addr = 18446744073709548367LLU; // 99999999MO'''''''''''''''
	53876	+ state.addr = 18446744073709548414LLU; // 99999999M8'''''''''''''''
54650	53877	break;
54651	53878	}
54652		- case 18446744073709548368LLU: // 99999999MP'''''''''''''''
	53879	+ case 18446744073709548415LLU: // 99999999M9'''''''''''''''
54653	53880	{
54654	53881	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resultargs at 18
54655	53882	// variable list<resdest___> tmpresults goes out of scope
54656	53883	// emitted destructur for type list<resdest___>
54657		- state.addr = 18446744073709548364LLU; // 99999999ML'''''''''''''''
	53884	+ state.addr = 18446744073709548411LLU; // 99999999M5'''''''''''''''
54658	53885	break;
54659	53886	}
54660		- case 18446744073709548364LLU: // 99999999ML'''''''''''''''
	53887	+ case 18446744073709548411LLU: // 99999999M5'''''''''''''''
54661	53888	{
54662	53889	if(!LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/list*/)
54663	53890	{
54664		- state.addr = 18446744073709548365LLU; // 99999999MM'''''''''''''''
	53891	+ state.addr = 18446744073709548412LLU; // 99999999M6'''''''''''''''
54665	53892	break;
54666	53893	}
54667	53894	// temporary list-element

		@@ -54675,7 +53902,7 @@
54675	53902	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54676	53903	}
54677	53904	// ACCUMULATE ARGUMENTS - END
54678		- uint64_t return_to = 18446744073709548363LLU;
	53905	+ uint64_t return_to = 18446744073709548410LLU;
54679	53906	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54680	53907	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54681	53908	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54684,14 +53911,14 @@
54684	53911	state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
54685	53912	break;
54686	53913	}
54687		- case 18446744073709548363LLU: // 99999999MK'''''''''''''''
	53914	+ case 18446744073709548410LLU: // 99999999M4'''''''''''''''
54688	53915	{
54689	53916	// RELEASE temporary destructor-variable
54690	53917	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
54691		- state.addr = 18446744073709548364LLU; // 99999999ML'''''''''''''''
	53918	+ state.addr = 18446744073709548411LLU; // 99999999M5'''''''''''''''
54692	53919	break;
54693	53920	}
54694		- case 18446744073709548365LLU: // 99999999MM'''''''''''''''
	53921	+ case 18446744073709548412LLU: // 99999999M6'''''''''''''''
54695	53922	{
54696	53923	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpresults at 17
54697	53924	// parameter-reference u64 remainheap goes out of scope

		@@ -54768,10 +53995,10 @@
54768	53995	uint64_t arg = 0;
54769	53996	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
54770	53997	}
54771		- state.addr = 18446744073709548362LLU; // 99999999MJ'''''''''''''''
	53998	+ state.addr = 18446744073709548409LLU; // 99999999M3'''''''''''''''
54772	53999	break;
54773	54000	}
54774		- case 18446744073709548362LLU: // 99999999MJ'''''''''''''''
	54001	+ case 18446744073709548409LLU: // 99999999M3'''''''''''''''
54775	54002	{
54776	54003	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
54777	54004	{

		@@ -54778,7 +54005,7 @@
54778	54005	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
54779	54006	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
54780	54007	{
54781		- state.addr = 18446744073709548361LLU; // 99999999MI'''''''''''''''
	54008	+ state.addr = 18446744073709548408LLU; // 99999999M2'''''''''''''''
54782	54009	break;
54783	54010	}
54784	54011	}

		@@ -54798,7 +54025,7 @@
54798	54025	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54799	54026	}
54800	54027	// ACCUMULATE ARGUMENTS - END
54801		- uint64_t return_to = 18446744073709548359LLU;
	54028	+ uint64_t return_to = 18446744073709548406LLU;
54802	54029	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
54803	54030	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54804	54031	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54807,17 +54034,17 @@
54807	54034	state.addr = 325750391286068249LLU; // RESDEFCOPY
54808	54035	break;
54809	54036	}
54810		- case 18446744073709548359LLU: // 99999999MG'''''''''''''''
	54037	+ case 18446744073709548406LLU: // 99999999M0'''''''''''''''
54811	54038	{
54812		- state.addr = 18446744073709548360LLU; // 99999999MH'''''''''''''''
	54039	+ state.addr = 18446744073709548407LLU; // 99999999M1'''''''''''''''
54813	54040	break;
54814	54041	}
54815		- case 18446744073709548360LLU: // 99999999MH'''''''''''''''
	54042	+ case 18446744073709548407LLU: // 99999999M1'''''''''''''''
54816	54043	{
54817		- state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &/tmprespars/LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709548358LLU : 18446744073709548357LLU;
	54044	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &/tmprespars/LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709548405LLU : 18446744073709548404LLU;
54818	54045	break;
54819	54046	}
54820		- case 18446744073709548358LLU: // 99999999MF'''''''''''''''
	54047	+ case 18446744073709548405LLU: // 99999999Mz'''''''''''''''
54821	54048	{
54822	54049	{
54823	54050	uint64_t arg = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU);

		@@ -54830,7 +54057,7 @@
54830	54057	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54831	54058	}
54832	54059	// ACCUMULATE ARGUMENTS - END
54833		- uint64_t return_to = 18446744073709548355LLU;
	54060	+ uint64_t return_to = 18446744073709548402LLU;
54834	54061	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54835	54062	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54836	54063	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54839,12 +54066,12 @@
54839	54066	state.addr = 819847183518272384LLU; // reportres_
54840	54067	break;
54841	54068	}
54842		- case 18446744073709548355LLU: // 99999999MC'''''''''''''''
	54069	+ case 18446744073709548402LLU: // 99999999Mw'''''''''''''''
54843	54070	{
54844		- state.addr = 18446744073709548356LLU; // 99999999MD'''''''''''''''
	54071	+ state.addr = 18446744073709548403LLU; // 99999999Mx'''''''''''''''
54845	54072	break;
54846	54073	}
54847		- case 18446744073709548356LLU: // 99999999MD'''''''''''''''
	54074	+ case 18446744073709548403LLU: // 99999999Mx'''''''''''''''
54848	54075	{
54849	54076	fprintf(stderr, "%s", "\n");
54850	54077	{

		@@ -54859,7 +54086,7 @@
54859	54086	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54860	54087	}
54861	54088	// ACCUMULATE ARGUMENTS - END
54862		- uint64_t return_to = 18446744073709548354LLU;
	54089	+ uint64_t return_to = 18446744073709548401LLU;
54863	54090	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54864	54091	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54865	54092	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54868,20 +54095,20 @@
54868	54095	state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
54869	54096	break;
54870	54097	}
54871		- case 18446744073709548354LLU: // 99999999MB'''''''''''''''
	54098	+ case 18446744073709548401LLU: // 99999999Mv'''''''''''''''
54872	54099	{
54873	54100	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 20
54874	54101	heap.availilable_size_for_dynamic_objects += 0LLU;
54875	54102	heap.availilable_size_for_dynamic_objects += 0LLU;
54876		- state.addr = 18446744073709548353LLU; // 99999999MA'''''''''''''''
	54103	+ state.addr = 18446744073709548400LLU; // 99999999Mu'''''''''''''''
54877	54104	break;
54878	54105	}
54879		- case 18446744073709548357LLU: // 99999999ME'''''''''''''''
	54106	+ case 18446744073709548404LLU: // 99999999My'''''''''''''''
54880	54107	{
54881		- state.addr = 18446744073709548353LLU; // 99999999MA'''''''''''''''
	54108	+ state.addr = 18446744073709548400LLU; // 99999999Mu'''''''''''''''
54882	54109	break;
54883	54110	}
54884		- case 18446744073709548353LLU: // 99999999MA'''''''''''''''
	54111	+ case 18446744073709548400LLU: // 99999999Mu'''''''''''''''
54885	54112	{
54886	54113	// variable resdest___ new_______ goes out of scope
54887	54114	// (uninitialized -> no destructor-call)

		@@ -54888,10 +54115,10 @@
54888	54115	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 19
54889	54116	// parameter-reference resdest___ res_______ goes out of scope
54890	54117	// parameter-reference list<resdest___> results___ goes out of scope
54891		- state.addr = 18446744073709548362LLU; // 99999999MJ'''''''''''''''
	54118	+ state.addr = 18446744073709548409LLU; // 99999999M3'''''''''''''''
54892	54119	break;
54893	54120	}
54894		- case 18446744073709548361LLU: // 99999999MI'''''''''''''''
	54121	+ case 18446744073709548408LLU: // 99999999M2'''''''''''''''
54895	54122	{
54896	54123	{
54897	54124	uint64_t arg = 0LLU;

		@@ -55003,7 +54230,7 @@
55003	54230	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55004	54231	}
55005	54232	// ACCUMULATE ARGUMENTS - END
55006		- uint64_t return_to = 18446744073709548351LLU;
	54233	+ uint64_t return_to = 18446744073709548398LLU;
55007	54234	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55008	54235	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55009	54236	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55012,12 +54239,12 @@
55012	54239	state.addr = 517555828430075934LLU; // assign_dec
55013	54240	break;
55014	54241	}
55015		- case 18446744073709548351LLU: // 99999999L9'''''''''''''''
	54242	+ case 18446744073709548398LLU: // 99999999Ms'''''''''''''''
55016	54243	{
55017		- state.addr = 18446744073709548352LLU; // 99999999M_'''''''''''''''
	54244	+ state.addr = 18446744073709548399LLU; // 99999999Mt'''''''''''''''
55018	54245	break;
55019	54246	}
55020		- case 18446744073709548352LLU: // 99999999M_'''''''''''''''
	54247	+ case 18446744073709548399LLU: // 99999999Mt'''''''''''''''
55021	54248	{
55022	54249	{
55023	54250	uint64_t arg = 0LLU;

		@@ -55033,7 +54260,7 @@
55033	54260	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55034	54261	}
55035	54262	// ACCUMULATE ARGUMENTS - END
55036		- uint64_t return_to = 18446744073709548349LLU;
	54263	+ uint64_t return_to = 18446744073709548396LLU;
55037	54264	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55038	54265	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55039	54266	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55042,12 +54269,12 @@
55042	54269	state.addr = 517555828430075934LLU; // assign_dec
55043	54270	break;
55044	54271	}
55045		- case 18446744073709548349LLU: // 99999999L7'''''''''''''''
	54272	+ case 18446744073709548396LLU: // 99999999Mq'''''''''''''''
55046	54273	{
55047		- state.addr = 18446744073709548350LLU; // 99999999L8'''''''''''''''
	54274	+ state.addr = 18446744073709548397LLU; // 99999999Mr'''''''''''''''
55048	54275	break;
55049	54276	}
55050		- case 18446744073709548350LLU: // 99999999L8'''''''''''''''
	54277	+ case 18446744073709548397LLU: // 99999999Mr'''''''''''''''
55051	54278	{
55052	54279	{
55053	54280	uint64_t arg = 0LLU;

		@@ -55063,7 +54290,7 @@
55063	54290	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55064	54291	}
55065	54292	// ACCUMULATE ARGUMENTS - END
55066		- uint64_t return_to = 18446744073709548346LLU;
	54293	+ uint64_t return_to = 18446744073709548393LLU;
55067	54294	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55068	54295	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55069	54296	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55072,20 +54299,20 @@
55072	54299	state.addr = 587881351406071808LLU; // emitjump__
55073	54300	break;
55074	54301	}
55075		- case 18446744073709548346LLU: // 99999999L4'''''''''''''''
	54302	+ case 18446744073709548393LLU: // 99999999Mn'''''''''''''''
55076	54303	{
55077		- state.addr = 18446744073709548347LLU; // 99999999L5'''''''''''''''
	54304	+ state.addr = 18446744073709548394LLU; // 99999999Mo'''''''''''''''
55078	54305	break;
55079	54306	}
55080		- case 18446744073709548347LLU: // 99999999L5'''''''''''''''
	54307	+ case 18446744073709548394LLU: // 99999999Mo'''''''''''''''
55081	54308	{
55082	54309	// variable u64 level_____ goes out of scope
55083	54310	// emitted destructur for type u64
55084	54311	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 18
55085		- state.addr = 18446744073709548348LLU; // 99999999L6'''''''''''''''
	54312	+ state.addr = 18446744073709548395LLU; // 99999999Mp'''''''''''''''
55086	54313	break;
55087	54314	}
55088		- case 18446744073709548348LLU: // 99999999L6'''''''''''''''
	54315	+ case 18446744073709548395LLU: // 99999999Mp'''''''''''''''
55089	54316	{
55090	54317	{
55091	54318	uint64_t arg = 658016168996666272LLU;

		@@ -55097,7 +54324,7 @@
55097	54324	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55098	54325	}
55099	54326	// ACCUMULATE ARGUMENTS - END
55100		- uint64_t return_to = 18446744073709548344LLU;
	54327	+ uint64_t return_to = 18446744073709548391LLU;
55101	54328	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55102	54329	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55103	54330	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55106,12 +54333,12 @@
55106	54333	state.addr = 839519719621918720LLU; // skipws____
55107	54334	break;
55108	54335	}
55109		- case 18446744073709548344LLU: // 99999999L2'''''''''''''''
	54336	+ case 18446744073709548391LLU: // 99999999Ml'''''''''''''''
55110	54337	{
55111		- state.addr = 18446744073709548345LLU; // 99999999L3'''''''''''''''
	54338	+ state.addr = 18446744073709548392LLU; // 99999999Mm'''''''''''''''
55112	54339	break;
55113	54340	}
55114		- case 18446744073709548345LLU: // 99999999L3'''''''''''''''
	54341	+ case 18446744073709548392LLU: // 99999999Mm'''''''''''''''
55115	54342	{
55116	54343	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 10LLU)));
55117	54344	{

		@@ -55134,10 +54361,10 @@
55134	54361	};
55135	54362	*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = arg;
55136	54363	}
55137		- state.addr = 18446744073709548342LLU; // 99999999L0'''''''''''''''
	54364	+ state.addr = 18446744073709548389LLU; // 99999999Mj'''''''''''''''
55138	54365	break;
55139	54366	}
55140		- case 18446744073709548342LLU: // 99999999L0'''''''''''''''
	54367	+ case 18446744073709548389LLU: // 99999999Mj'''''''''''''''
55141	54368	{
55142	54369	{
55143	54370	uint64_t arg = 0LLU;

		@@ -55149,7 +54376,7 @@
55149	54376	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55150	54377	}
55151	54378	// ACCUMULATE ARGUMENTS - END
55152		- uint64_t return_to = 18446744073709548340LLU;
	54379	+ uint64_t return_to = 18446744073709548387LLU;
55153	54380	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55154	54381	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55155	54382	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55158,12 +54385,12 @@
55158	54385	state.addr = 839519719621918720LLU; // skipws____
55159	54386	break;
55160	54387	}
55161		- case 18446744073709548340LLU: // 99999999Ly'''''''''''''''
	54388	+ case 18446744073709548387LLU: // 99999999Mh'''''''''''''''
55162	54389	{
55163		- state.addr = 18446744073709548341LLU; // 99999999Lz'''''''''''''''
	54390	+ state.addr = 18446744073709548388LLU; // 99999999Mi'''''''''''''''
55164	54391	break;
55165	54392	}
55166		- case 18446744073709548341LLU: // 99999999Lz'''''''''''''''
	54393	+ case 18446744073709548388LLU: // 99999999Mi'''''''''''''''
55167	54394	{
55168	54395	/id0_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 10LLU)));
55169	54396	{

		@@ -55236,7 +54463,7 @@
55236	54463	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55237	54464	}
55238	54465	// ACCUMULATE ARGUMENTS - END
55239		- uint64_t return_to = 18446744073709548336LLU;
	54466	+ uint64_t return_to = 18446744073709548383LLU;
55240	54467	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
55241	54468	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55242	54469	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55245,20 +54472,20 @@
55245	54472	state.addr = 604790753280317473LLU; // findvarref
55246	54473	break;
55247	54474	}
55248		- case 18446744073709548336LLU: // 99999999Lu'''''''''''''''
	54475	+ case 18446744073709548383LLU: // 99999999Md'''''''''''''''
55249	54476	{
55250		- state.addr = 18446744073709548337LLU; // 99999999Lv'''''''''''''''
	54477	+ state.addr = 18446744073709548384LLU; // 99999999Me'''''''''''''''
55251	54478	break;
55252	54479	}
55253		- case 18446744073709548337LLU: // 99999999Lv'''''''''''''''
	54480	+ case 18446744073709548384LLU: // 99999999Me'''''''''''''''
55254	54481	{
55255	54482	// variable u64 optelem___ goes out of scope
55256	54483	// emitted destructur for type u64
55257	54484	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 27
55258		- state.addr = 18446744073709548338LLU; // 99999999Lw'''''''''''''''
	54485	+ state.addr = 18446744073709548385LLU; // 99999999Mf'''''''''''''''
55259	54486	break;
55260	54487	}
55261		- case 18446744073709548338LLU: // 99999999Lw'''''''''''''''
	54488	+ case 18446744073709548385LLU: // 99999999Mf'''''''''''''''
55262	54489	{
55263	54490	// ACCUMULATE ARGUMENTS - BEGIN
55264	54491	{

		@@ -55270,7 +54497,7 @@
55270	54497	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55271	54498	}
55272	54499	// ACCUMULATE ARGUMENTS - END
55273		- uint64_t return_to = 18446744073709548334LLU;
	54500	+ uint64_t return_to = 18446744073709548381LLU;
55274	54501	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55275	54502	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55276	54503	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55279,12 +54506,12 @@
55279	54506	state.addr = 517555565476695680LLU; // assertu64_
55280	54507	break;
55281	54508	}
55282		- case 18446744073709548334LLU: // 99999999Ls'''''''''''''''
	54509	+ case 18446744073709548381LLU: // 99999999Mb'''''''''''''''
55283	54510	{
55284		- state.addr = 18446744073709548335LLU; // 99999999Lt'''''''''''''''
	54511	+ state.addr = 18446744073709548382LLU; // 99999999Mc'''''''''''''''
55285	54512	break;
55286	54513	}
55287		- case 18446744073709548335LLU: // 99999999Lt'''''''''''''''
	54514	+ case 18446744073709548382LLU: // 99999999Mc'''''''''''''''
55288	54515	{
55289	54516	// ACCUMULATE ARGUMENTS - BEGIN
55290	54517	{

		@@ -55304,7 +54531,7 @@
55304	54531	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55305	54532	}
55306	54533	// ACCUMULATE ARGUMENTS - END
55307		- uint64_t return_to = 18446744073709548332LLU;
	54534	+ uint64_t return_to = 18446744073709548379LLU;
55308	54535	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55309	54536	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55310	54537	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55313,12 +54540,12 @@
55313	54540	state.addr = 660220410725010287LLU; // initassert
55314	54541	break;
55315	54542	}
55316		- case 18446744073709548332LLU: // 99999999Lq'''''''''''''''
	54543	+ case 18446744073709548379LLU: // 99999999M$'''''''''''''''
55317	54544	{
55318		- state.addr = 18446744073709548333LLU; // 99999999Lr'''''''''''''''
	54545	+ state.addr = 18446744073709548380LLU; // 99999999Ma'''''''''''''''
55319	54546	break;
55320	54547	}
55321		- case 18446744073709548333LLU: // 99999999Lr'''''''''''''''
	54548	+ case 18446744073709548380LLU: // 99999999Ma'''''''''''''''
55322	54549	{
55323	54550	// variable u64 consume___ goes out of scope
55324	54551	// emitted destructur for type u64

		@@ -55332,10 +54559,10 @@
55332	54559	// variable u64 mutable___ goes out of scope
55333	54560	// emitted destructur for type u64
55334	54561	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 23
55335		- state.addr = 18446744073709548339LLU; // 99999999Lx'''''''''''''''
	54562	+ state.addr = 18446744073709548386LLU; // 99999999Mg'''''''''''''''
55336	54563	break;
55337	54564	}
55338		- case 18446744073709548339LLU: // 99999999Lx'''''''''''''''
	54565	+

Part of diff was cut off due to size limit. Use your local client to view the full diff.

Show on old repository browser