• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revisão953 (tree)
Hora2020-03-27 09:18:51
Autorjakobthomsen

Mensagem de Log

return-syntax for embedded c-code

Mudança Sumário

Diff

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (revision 952)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (revision 953)
@@ -58724,9 +58724,26 @@
5872458724 }
5872558725 case 787472338265246569LLU: // procreturn
5872658726 {
58727- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 10LLU)) ? 18446744073709548183LLU : 18446744073709548182LLU;
58727+ // ACCUMULATE ARGUMENTS - BEGIN
58728+ {
58729+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
58730+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58731+ }
58732+ // ACCUMULATE ARGUMENTS - END
58733+ uint64_t return_to = 18446744073709548182LLU;
58734+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
58735+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
58736+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
58737+ heap.data[0].elem1 = heap.data[0].elem0;
58738+ heap.data[0].elem0 = restore;
58739+ state.addr = 839519719621918720LLU; // skipws____
5872858740 break;
5872958741 }
58742+ case 18446744073709548182LLU: // 99999999JV'''''''''''''''
58743+ {
58744+ state.addr = 18446744073709548183LLU; // 99999999JW'''''''''''''''
58745+ break;
58746+ }
5873058747 case 18446744073709548183LLU: // 99999999JW'''''''''''''''
5873158748 {
5873258749 {
@@ -58733,38 +58750,160 @@
5873358750 uint64_t arg = 0;
5873458751 LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5873558752 }
58736- *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 1;
58753+ *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 96;
5873758754 {
58738- uint64_t arg = /*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU));
58755+ uint64_t arg = 0;
5873958756 LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5874058757 }
58758+ *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = 0;
58759+ /*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));
58760+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548181LLU : 18446744073709548180LLU;
58761+ break;
58762+ }
58763+ case 18446744073709548181LLU: // 99999999JU'''''''''''''''
58764+ {
58765+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 4LLU)) ? 18446744073709548179LLU : 18446744073709548178LLU;
58766+ break;
58767+ }
58768+ case 18446744073709548179LLU: // 99999999JS'''''''''''''''
58769+ {
58770+ // ACCUMULATE ARGUMENTS - BEGIN
58771+ {
58772+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 18LLU, 0LLU);
58773+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58774+ }
58775+ // ACCUMULATE ARGUMENTS - END
58776+ uint64_t return_to = 18446744073709548176LLU;
58777+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
58778+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
58779+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
58780+ heap.data[0].elem1 = heap.data[0].elem0;
58781+ heap.data[0].elem0 = restore;
58782+ state.addr = 819847183515949359LLU; // reportinit
58783+ break;
58784+ }
58785+ case 18446744073709548176LLU: // 99999999JP'''''''''''''''
58786+ {
58787+ state.addr = 18446744073709548177LLU; // 99999999JQ'''''''''''''''
58788+ break;
58789+ }
58790+ case 18446744073709548177LLU: // 99999999JQ'''''''''''''''
58791+ {
5874158792 {
58793+ fprintf(stderr, "%s\n", "can't return c-code in safe environment");
58794+ exit(-1);
58795+ }
58796+ state.addr = 18446744073709548178LLU; // 99999999JR'''''''''''''''
58797+ break;
58798+ }
58799+ case 18446744073709548178LLU: // 99999999JR'''''''''''''''
58800+ {
58801+ state.addr = 18446744073709548175LLU; // 99999999JO'''''''''''''''
58802+ break;
58803+ }
58804+ case 18446744073709548175LLU: // 99999999JO'''''''''''''''
58805+ {
58806+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
58807+ if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255)
58808+ {
58809+ state.addr = 18446744073709548174LLU; // 99999999JN'''''''''''''''
58810+ break;
58811+ }
58812+ /*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));
58813+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548173LLU : 18446744073709548172LLU;
58814+ break;
58815+ }
58816+ case 18446744073709548173LLU: // 99999999JM'''''''''''''''
58817+ {
58818+ ungetc(0, stdin);
58819+ heap.availilable_size_for_dynamic_objects += 0LLU;
58820+ heap.availilable_size_for_dynamic_objects += 0LLU;
58821+ state.addr = 18446744073709548171LLU; // 99999999JK'''''''''''''''
58822+ break;
58823+ }
58824+ case 18446744073709548172LLU: // 99999999JL'''''''''''''''
58825+ {
58826+ // ACCUMULATE ARGUMENTS - BEGIN
58827+ {
58828+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU);
58829+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
58830+ }
58831+ // ACCUMULATE ARGUMENTS - END
58832+ uint64_t return_to = 18446744073709548169LLU;
58833+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
58834+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
58835+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
58836+ heap.data[0].elem1 = heap.data[0].elem0;
58837+ heap.data[0].elem0 = restore;
58838+ state.addr = 587881343588366336LLU; // emitccode_
58839+ break;
58840+ }
58841+ case 18446744073709548169LLU: // 99999999JI'''''''''''''''
58842+ {
58843+ state.addr = 18446744073709548170LLU; // 99999999JJ'''''''''''''''
58844+ break;
58845+ }
58846+ case 18446744073709548170LLU: // 99999999JJ'''''''''''''''
58847+ {
58848+ state.addr = 18446744073709548171LLU; // 99999999JK'''''''''''''''
58849+ break;
58850+ }
58851+ case 18446744073709548171LLU: // 99999999JK'''''''''''''''
58852+ {
58853+ state.addr = 18446744073709548175LLU; // 99999999JO'''''''''''''''
58854+ break;
58855+ }
58856+ case 18446744073709548174LLU: // 99999999JN'''''''''''''''
58857+ {
58858+ /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
58859+ heap.availilable_size_for_dynamic_objects += 0LLU;
58860+ heap.availilable_size_for_dynamic_objects += 0LLU;
58861+ state.addr = 18446744073709548168LLU; // 99999999JH'''''''''''''''
58862+ break;
58863+ }
58864+ case 18446744073709548180LLU: // 99999999JT'''''''''''''''
58865+ {
58866+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 10LLU)) ? 18446744073709548167LLU : 18446744073709548166LLU;
58867+ break;
58868+ }
58869+ case 18446744073709548167LLU: // 99999999JG'''''''''''''''
58870+ {
58871+ {
5874258872 uint64_t arg = 0;
5874358873 LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5874458874 }
58745- state.addr = 18446744073709548181LLU; // 99999999JU'''''''''''''''
58875+ *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 1;
58876+ {
58877+ uint64_t arg = /*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU));
58878+ LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58879+ }
58880+ {
58881+ uint64_t arg = 0;
58882+ LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58883+ }
58884+ state.addr = 18446744073709548165LLU; // 99999999JE'''''''''''''''
5874658885 break;
5874758886 }
58748- case 18446744073709548181LLU: // 99999999JU'''''''''''''''
58887+ case 18446744073709548165LLU: // 99999999JE'''''''''''''''
5874958888 {
58750- if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU))
58889+ if(!*LOCAL_ACCESS(heap.data, 21LLU, 19LLU))
5875158890 {
58752- (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
58753- (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
58891+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21
58892+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20
5875458893 {
58755- state.addr = 18446744073709548180LLU; // 99999999JT'''''''''''''''
58894+ state.addr = 18446744073709548164LLU; // 99999999JD'''''''''''''''
5875658895 break;
5875758896 }
5875858897 }
58759- /*direct*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = (*LOCAL_ACCESS(heap.data, 19LLU, 17LLU) << 1) + 1LLU;
58760- *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) = heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)].elem0;
58898+ /*direct*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = (*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) << 1) + 1LLU;
58899+ *LOCAL_ACCESS(heap.data, 21LLU, 19LLU) = heap.data[*LOCAL_ACCESS(heap.data, 21LLU, 19LLU)].elem0;
5876158900 // ACCUMULATE ARGUMENTS - BEGIN
5876258901 {
58763- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 19LLU, 11LLU);
58902+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU);
5876458903 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5876558904 }
5876658905 // ACCUMULATE ARGUMENTS - END
58767- uint64_t return_to = 18446744073709548178LLU;
58906+ uint64_t return_to = 18446744073709548162LLU;
5876858907 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5876958908 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5877058909 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58773,41 +58912,41 @@
5877358912 state.addr = 839519719621918720LLU; // skipws____
5877458913 break;
5877558914 }
58776- case 18446744073709548178LLU: // 99999999JR'''''''''''''''
58915+ case 18446744073709548162LLU: // 99999999JB'''''''''''''''
5877758916 {
58778- state.addr = 18446744073709548179LLU; // 99999999JS'''''''''''''''
58917+ state.addr = 18446744073709548163LLU; // 99999999JC'''''''''''''''
5877958918 break;
5878058919 }
58781- case 18446744073709548179LLU: // 99999999JS'''''''''''''''
58920+ case 18446744073709548163LLU: // 99999999JC'''''''''''''''
5878258921 {
58783- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548177LLU : 18446744073709548176LLU;
58922+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 18LLU) ? 18446744073709548161LLU : 18446744073709548160LLU;
5878458923 break;
5878558924 }
58786- case 18446744073709548177LLU: // 99999999JQ'''''''''''''''
58925+ case 18446744073709548161LLU: // 99999999JA'''''''''''''''
5878758926 {
58788- matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
58789- *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) = 0LLU;
58927+ matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
58928+ *LOCAL_ACCESS(heap.data, 21LLU, 18LLU) = 0LLU;
5879058929
5879158930 heap.availilable_size_for_dynamic_objects += 0LLU;
5879258931 heap.availilable_size_for_dynamic_objects += 0LLU;
58793- state.addr = 18446744073709548175LLU; // 99999999JO'''''''''''''''
58932+ state.addr = 18446744073709548159LLU; // 99999999I9'''''''''''''''
5879458933 break;
5879558934 }
58796- case 18446744073709548176LLU: // 99999999JP'''''''''''''''
58935+ case 18446744073709548160LLU: // 99999999J_'''''''''''''''
5879758936 {
58798- matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
58799- state.addr = 18446744073709548175LLU; // 99999999JO'''''''''''''''
58937+ matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
58938+ state.addr = 18446744073709548159LLU; // 99999999I9'''''''''''''''
5880058939 break;
5880158940 }
58802- case 18446744073709548175LLU: // 99999999JO'''''''''''''''
58941+ case 18446744073709548159LLU: // 99999999I9'''''''''''''''
5880358942 {
5880458943 // ACCUMULATE ARGUMENTS - BEGIN
5880558944 {
58806- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 19LLU, 11LLU);
58945+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU);
5880758946 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5880858947 }
5880958948 // ACCUMULATE ARGUMENTS - END
58810- uint64_t return_to = 18446744073709548173LLU;
58949+ uint64_t return_to = 18446744073709548157LLU;
5881158950 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5881258951 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5881358952 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58816,28 +58955,28 @@
5881658955 state.addr = 839519719621918720LLU; // skipws____
5881758956 break;
5881858957 }
58819- case 18446744073709548173LLU: // 99999999JM'''''''''''''''
58958+ case 18446744073709548157LLU: // 99999999I7'''''''''''''''
5882058959 {
58821- state.addr = 18446744073709548174LLU; // 99999999JN'''''''''''''''
58960+ state.addr = 18446744073709548158LLU; // 99999999I8'''''''''''''''
5882258961 break;
5882358962 }
58824- case 18446744073709548174LLU: // 99999999JN'''''''''''''''
58963+ case 18446744073709548158LLU: // 99999999I8'''''''''''''''
5882558964 {
5882658965 {
5882758966 uint64_t arg = 0;
58828- LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
58967+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5882958968 }
5883058969 // ACCUMULATE ARGUMENTS - BEGIN
5883158970 {
58832- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
58971+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
5883358972 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5883458973 }
5883558974 {
58836- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 20LLU, 11LLU);
58975+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU);
5883758976 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5883858977 }
5883958978 // ACCUMULATE ARGUMENTS - END
58840- uint64_t return_to = 18446744073709548169LLU;
58979+ uint64_t return_to = 18446744073709548153LLU;
5884158980 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5884258981 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5884358982 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58846,30 +58985,30 @@
5884658985 state.addr = 661605045736570880LLU; // isdigit___
5884758986 break;
5884858987 }
58849- case 18446744073709548169LLU: // 99999999JI'''''''''''''''
58988+ case 18446744073709548153LLU: // 99999999I3'''''''''''''''
5885058989 {
58851- state.addr = 18446744073709548170LLU; // 99999999JJ'''''''''''''''
58990+ state.addr = 18446744073709548154LLU; // 99999999I4'''''''''''''''
5885258991 break;
5885358992 }
58854- case 18446744073709548170LLU: // 99999999JJ'''''''''''''''
58993+ case 18446744073709548154LLU: // 99999999I4'''''''''''''''
5885558994 {
58856- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548172LLU : 18446744073709548171LLU;
58857- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20
58995+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548156LLU : 18446744073709548155LLU;
58996+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22
5885858997 break;
5885958998 }
58860- case 18446744073709548172LLU: // 99999999JL'''''''''''''''
58999+ case 18446744073709548156LLU: // 99999999I6'''''''''''''''
5886159000 {
5886259001 // ACCUMULATE ARGUMENTS - BEGIN
5886359002 {
58864- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 19LLU, 0LLU);
59003+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 21LLU, 0LLU);
5886559004 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5886659005 }
5886759006 {
58868- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 19LLU, 18LLU), 0LLU);
59007+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 20LLU), 0LLU);
5886959008 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5887059009 }
5887159010 // ACCUMULATE ARGUMENTS - END
58872- uint64_t return_to = 18446744073709548167LLU;
59011+ uint64_t return_to = 18446744073709548151LLU;
5887359012 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5887459013 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5887559014 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58878,43 +59017,43 @@
5887859017 state.addr = 517555565476695680LLU; // assertu64_
5887959018 break;
5888059019 }
58881- case 18446744073709548167LLU: // 99999999JG'''''''''''''''
59020+ case 18446744073709548151LLU: // 99999999I1'''''''''''''''
5888259021 {
58883- state.addr = 18446744073709548168LLU; // 99999999JH'''''''''''''''
59022+ state.addr = 18446744073709548152LLU; // 99999999I2'''''''''''''''
5888459023 break;
5888559024 }
58886- case 18446744073709548168LLU: // 99999999JH'''''''''''''''
59025+ case 18446744073709548152LLU: // 99999999I2'''''''''''''''
5888759026 {
5888859027 {
5888959028 uint64_t arg = 0;
58890- LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59029+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5889159030 }
58892- *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
58893- /*n_________*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
59031+ *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 0;
59032+ /*n_________*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
5889459033 fprintf(stdout, "%s", "\n ");
5889559034 // ACCUMULATE ARGUMENTS - BEGIN
5889659035 {
58897- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 20LLU, 12LLU);
59036+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU);
5889859037 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5889959038 }
5890059039 {
58901- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 20LLU, 13LLU);
59040+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU);
5890259041 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5890359042 }
5890459043 {
58905- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 20LLU, 14LLU);
59044+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU);
5890659045 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5890759046 }
5890859047 {
58909- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 20LLU, 18LLU), 1LLU);
59048+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 20LLU), 1LLU);
5891059049 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5891159050 }
5891259051 {
58913- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 20LLU, 18LLU), 2LLU);
59052+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 20LLU), 2LLU);
5891459053 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5891559054 }
5891659055 // ACCUMULATE ARGUMENTS - END
58917- uint64_t return_to = 18446744073709548165LLU;
59056+ uint64_t return_to = 18446744073709548149LLU;
5891859057 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5891959058 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5892059059 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58923,21 +59062,21 @@
5892359062 state.addr = 587881357514113024LLU; // emitpar___
5892459063 break;
5892559064 }
58926- case 18446744073709548165LLU: // 99999999JE'''''''''''''''
59065+ case 18446744073709548149LLU: // 99999999Iz'''''''''''''''
5892759066 {
58928- state.addr = 18446744073709548166LLU; // 99999999JF'''''''''''''''
59067+ state.addr = 18446744073709548150LLU; // 99999999I0'''''''''''''''
5892959068 break;
5893059069 }
58931- case 18446744073709548166LLU: // 99999999JF'''''''''''''''
59070+ case 18446744073709548150LLU: // 99999999I0'''''''''''''''
5893259071 {
5893359072 fprintf(stdout, "%s", " = ");
5893459073 // ACCUMULATE ARGUMENTS - BEGIN
5893559074 {
58936- uint64_t arg = /*n_________*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
59075+ uint64_t arg = /*n_________*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
5893759076 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5893859077 }
5893959078 // ACCUMULATE ARGUMENTS - END
58940- uint64_t return_to = 18446744073709548163LLU;
59079+ uint64_t return_to = 18446744073709548147LLU;
5894159080 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5894259081 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5894359082 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58946,37 +59085,37 @@
5894659085 state.addr = 787446708198178816LLU; // printnr___
5894759086 break;
5894859087 }
58949- case 18446744073709548163LLU: // 99999999JC'''''''''''''''
59088+ case 18446744073709548147LLU: // 99999999Ix'''''''''''''''
5895059089 {
58951- state.addr = 18446744073709548164LLU; // 99999999JD'''''''''''''''
59090+ state.addr = 18446744073709548148LLU; // 99999999Iy'''''''''''''''
5895259091 break;
5895359092 }
58954- case 18446744073709548164LLU: // 99999999JD'''''''''''''''
59093+ case 18446744073709548148LLU: // 99999999Iy'''''''''''''''
5895559094 {
5895659095 fprintf(stdout, "%s", ";");
5895759096 // variable u64 n_________ goes out of scope
5895859097 // emitted destructur for type u64
58959- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference n_________ at 20
59098+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference n_________ at 22
5896059099 heap.availilable_size_for_dynamic_objects += 0LLU;
5896159100 heap.availilable_size_for_dynamic_objects += 0LLU;
58962- state.addr = 18446744073709548162LLU; // 99999999JB'''''''''''''''
59101+ state.addr = 18446744073709548146LLU; // 99999999Iw'''''''''''''''
5896359102 break;
5896459103 }
58965- case 18446744073709548171LLU: // 99999999JK'''''''''''''''
59104+ case 18446744073709548155LLU: // 99999999I5'''''''''''''''
5896659105 {
5896759106 {
5896859107 uint64_t arg = 0;
58969- LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59108+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5897059109 }
58971- *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
58972- /*id1_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
59110+ *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 0;
59111+ /*id1_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
5897359112 // ACCUMULATE ARGUMENTS - BEGIN
5897459113 {
58975- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 20LLU, 11LLU);
59114+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU);
5897659115 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5897759116 }
5897859117 // ACCUMULATE ARGUMENTS - END
58979- uint64_t return_to = 18446744073709548160LLU;
59118+ uint64_t return_to = 18446744073709548144LLU;
5898059119 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5898159120 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5898259121 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -58985,52 +59124,49 @@
5898559124 state.addr = 839519719621918720LLU; // skipws____
5898659125 break;
5898759126 }
58988- case 18446744073709548160LLU: // 99999999J_'''''''''''''''
59127+ case 18446744073709548144LLU: // 99999999Iu'''''''''''''''
5898959128 {
58990- state.addr = 18446744073709548161LLU; // 99999999JA'''''''''''''''
59129+ state.addr = 18446744073709548145LLU; // 99999999Iv'''''''''''''''
5899159130 break;
5899259131 }
58993- case 18446744073709548161LLU: // 99999999JA'''''''''''''''
59132+ case 18446744073709548145LLU: // 99999999Iv'''''''''''''''
5899459133 {
59134+ *LOCAL_ACCESS(heap.data, 22LLU, 16LLU) = 40LLU;
59135+
5899559136 {
5899659137 uint64_t arg = 0;
58997- LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59138+ LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5899859139 }
58999- *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 40;
59000- {
59001- uint64_t arg = 0;
59002- LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59003- }
59004- *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 0;
59005- /*called____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
59006- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548159LLU : 18446744073709548158LLU;
59140+ *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0;
59141+ /*called____*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 23LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 11LLU));
59142+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709548143LLU : 18446744073709548142LLU;
5900759143 break;
5900859144 }
59009- case 18446744073709548159LLU: // 99999999I9'''''''''''''''
59145+ case 18446744073709548143LLU: // 99999999It'''''''''''''''
5901059146 {
5901159147 {
5901259148 uint64_t arg = 0;
59013- LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59149+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5901459150 }
5901559151 // ACCUMULATE ARGUMENTS - BEGIN
5901659152 {
59017- uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59153+ uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
5901859154 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5901959155 }
5902059156 {
59021- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 0LLU);
59157+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 24LLU, 20LLU), 0LLU);
5902259158 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5902359159 }
5902459160 {
59025- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 1LLU);
59161+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 24LLU, 20LLU), 1LLU);
5902659162 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5902759163 }
5902859164 {
59029- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 23LLU, 18LLU), 2LLU);
59165+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 24LLU, 20LLU), 2LLU);
5903059166 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5903159167 }
5903259168 // ACCUMULATE ARGUMENTS - END
59033- uint64_t return_to = 18446744073709548156LLU;
59169+ uint64_t return_to = 18446744073709548140LLU;
5903459170 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5903559171 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5903659172 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59039,84 +59175,84 @@
5903959175 state.addr = 768289076452424640LLU; // oneresult_
5904059176 break;
5904159177 }
59042- case 18446744073709548156LLU: // 99999999I6'''''''''''''''
59178+ case 18446744073709548140LLU: // 99999999Iq'''''''''''''''
5904359179 {
59044- state.addr = 18446744073709548157LLU; // 99999999I7'''''''''''''''
59180+ state.addr = 18446744073709548141LLU; // 99999999Ir'''''''''''''''
5904559181 break;
5904659182 }
59047- case 18446744073709548157LLU: // 99999999I7'''''''''''''''
59183+ case 18446744073709548141LLU: // 99999999Ir'''''''''''''''
5904859184 {
5904959185 // ACCUMULATE ARGUMENTS - BEGIN
5905059186 {
59051- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 23LLU, 0LLU);
59187+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 24LLU, 0LLU);
5905259188 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5905359189 }
5905459190 {
59055- uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 23LLU, 1LLU);
59191+ uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 24LLU, 1LLU);
5905659192 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5905759193 }
5905859194 {
59059- uint64_t arg = /*complete__*/*LOCAL_ACCESS(heap.data, 23LLU, 2LLU);
59195+ uint64_t arg = /*complete__*/*LOCAL_ACCESS(heap.data, 24LLU, 2LLU);
5906059196 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5906159197 }
5906259198 {
59063- uint64_t arg = /*finite____*/*LOCAL_ACCESS(heap.data, 23LLU, 3LLU);
59199+ uint64_t arg = /*finite____*/*LOCAL_ACCESS(heap.data, 24LLU, 3LLU);
5906459200 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5906559201 }
5906659202 {
59067- uint64_t arg = /*safe______*/*LOCAL_ACCESS(heap.data, 23LLU, 4LLU);
59203+ uint64_t arg = /*safe______*/*LOCAL_ACCESS(heap.data, 24LLU, 4LLU);
5906859204 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5906959205 }
5907059206 {
59071- uint64_t arg = /*translate_*/*LOCAL_ACCESS(heap.data, 23LLU, 5LLU);
59207+ uint64_t arg = /*translate_*/*LOCAL_ACCESS(heap.data, 24LLU, 5LLU);
5907259208 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5907359209 }
5907459210 {
59075- uint64_t arg = /*fndefs____*/*LOCAL_ACCESS(heap.data, 23LLU, 6LLU);
59211+ uint64_t arg = /*fndefs____*/*LOCAL_ACCESS(heap.data, 24LLU, 6LLU);
5907659212 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5907759213 }
5907859214 {
59079- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU);
59215+ uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 24LLU, 7LLU);
5908059216 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5908159217 }
5908259218 {
59083- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 19LLU);
59219+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 24LLU, 21LLU);
5908459220 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5908559221 }
5908659222 {
59087- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 23LLU, 8LLU);
59223+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 24LLU, 8LLU);
5908859224 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5908959225 }
5909059226 {
59091- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 23LLU, 9LLU);
59227+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 24LLU, 9LLU);
5909259228 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5909359229 }
5909459230 {
59095- uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59231+ uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
5909659232 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5909759233 }
5909859234 {
59099- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU);
59235+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 24LLU, 11LLU);
5910059236 LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5910159237 }
5910259238 {
59103- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 23LLU, 12LLU);
59239+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 24LLU, 12LLU);
5910459240 LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5910559241 }
5910659242 {
59107- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 23LLU, 13LLU);
59243+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 24LLU, 13LLU);
5910859244 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5910959245 }
5911059246 {
59111- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 23LLU, 14LLU);
59247+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 24LLU, 14LLU);
5911259248 LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5911359249 }
5911459250 {
59115- uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 23LLU, 15LLU);
59251+ uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 24LLU, 15LLU);
5911659252 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5911759253 }
5911859254 // ACCUMULATE ARGUMENTS - END
59119- uint64_t return_to = 18446744073709548154LLU;
59255+ uint64_t return_to = 18446744073709548138LLU;
5912059256 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
5912159257 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5912259258 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59125,37 +59261,37 @@
5912559261 state.addr = 782701543315110336LLU; // parsecall_
5912659262 break;
5912759263 }
59128- case 18446744073709548154LLU: // 99999999I4'''''''''''''''
59264+ case 18446744073709548138LLU: // 99999999Io'''''''''''''''
5912959265 {
59130- state.addr = 18446744073709548155LLU; // 99999999I5'''''''''''''''
59266+ state.addr = 18446744073709548139LLU; // 99999999Ip'''''''''''''''
5913159267 break;
5913259268 }
59133- case 18446744073709548155LLU: // 99999999I5'''''''''''''''
59269+ case 18446744073709548139LLU: // 99999999Ip'''''''''''''''
5913459270 {
5913559271 // variable list<resdest___> newresults goes out of scope
5913659272 // emitted destructur for type list<resdest___>
59137- state.addr = 18446744073709548152LLU; // 99999999I2'''''''''''''''
59273+ state.addr = 18446744073709548136LLU; // 99999999Im'''''''''''''''
5913859274 break;
5913959275 }
59140- case 18446744073709548152LLU: // 99999999I2'''''''''''''''
59276+ case 18446744073709548136LLU: // 99999999Im'''''''''''''''
5914159277 {
59142- if(!*LOCAL_ACCESS(heap.data, 23LLU, 22LLU)/*list*/)
59278+ if(!*LOCAL_ACCESS(heap.data, 24LLU, 23LLU)/*list*/)
5914359279 {
59144- state.addr = 18446744073709548153LLU; // 99999999I3'''''''''''''''
59280+ state.addr = 18446744073709548137LLU; // 99999999In'''''''''''''''
5914559281 break;
5914659282 }
5914759283 // temporary list-element
5914859284 {
59149- uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 23LLU, 22LLU)/*list*/, 8);
59150- LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59285+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 24LLU, 23LLU)/*list*/, 8);
59286+ LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5915159287 }
5915259288 // ACCUMULATE ARGUMENTS - BEGIN
5915359289 {
59154- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
59290+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 25LLU, 24LLU);
5915559291 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5915659292 }
5915759293 // ACCUMULATE ARGUMENTS - END
59158- uint64_t return_to = 18446744073709548151LLU;
59294+ uint64_t return_to = 18446744073709548135LLU;
5915959295 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5916059296 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5916159297 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59164,35 +59300,35 @@
5916459300 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
5916559301 break;
5916659302 }
59167- case 18446744073709548151LLU: // 99999999I1'''''''''''''''
59303+ case 18446744073709548135LLU: // 99999999Il'''''''''''''''
5916859304 {
5916959305 // RELEASE temporary destructor-variable
59170- (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 24
59171- state.addr = 18446744073709548152LLU; // 99999999I2'''''''''''''''
59306+ (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 25
59307+ state.addr = 18446744073709548136LLU; // 99999999Im'''''''''''''''
5917259308 break;
5917359309 }
59174- case 18446744073709548153LLU: // 99999999I3'''''''''''''''
59310+ case 18446744073709548137LLU: // 99999999In'''''''''''''''
5917559311 {
59176- (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 23
59312+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 24
5917759313 heap.availilable_size_for_dynamic_objects += 0LLU;
5917859314 heap.availilable_size_for_dynamic_objects += 0LLU;
59179- state.addr = 18446744073709548150LLU; // 99999999I0'''''''''''''''
59315+ state.addr = 18446744073709548134LLU; // 99999999Ik'''''''''''''''
5918059316 break;
5918159317 }
59182- case 18446744073709548158LLU: // 99999999I8'''''''''''''''
59318+ case 18446744073709548142LLU: // 99999999Is'''''''''''''''
5918359319 {
5918459320 fprintf(stdout, "%s", "\n swap(&");
5918559321 {
5918659322 uint64_t arg = 0;
59187- LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59323+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5918859324 }
5918959325 // ACCUMULATE ARGUMENTS - BEGIN
5919059326 {
59191- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59327+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
5919259328 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5919359329 }
5919459330 // ACCUMULATE ARGUMENTS - END
59195- uint64_t return_to = 18446744073709548148LLU;
59331+ uint64_t return_to = 18446744073709548132LLU;
5919659332 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5919759333 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5919859334 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59201,20 +59337,15 @@
5920159337 state.addr = 861504796319285248LLU; // typeu64___
5920259338 break;
5920359339 }
59204- case 18446744073709548148LLU: // 99999999Iy'''''''''''''''
59340+ case 18446744073709548132LLU: // 99999999Ii'''''''''''''''
5920559341 {
59206- state.addr = 18446744073709548149LLU; // 99999999Iz'''''''''''''''
59342+ state.addr = 18446744073709548133LLU; // 99999999Ij'''''''''''''''
5920759343 break;
5920859344 }
59209- case 18446744073709548149LLU: // 99999999Iz'''''''''''''''
59345+ case 18446744073709548133LLU: // 99999999Ij'''''''''''''''
5921059346 {
5921159347 {
5921259348 uint64_t arg = 0;
59213- LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59214- }
59215- *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = 0;
59216- {
59217- uint64_t arg = 0;
5921859349 LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5921959350 }
5922059351 *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = 0;
@@ -59243,57 +59374,62 @@
5924359374 LOCAL_PUSH_MOVE(&heap, 29, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5924459375 }
5924559376 *LOCAL_ACCESS(heap.data, 30LLU, 29LLU) = 0;
59377+ {
59378+ uint64_t arg = 0;
59379+ LOCAL_PUSH_MOVE(&heap, 30, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59380+ }
59381+ *LOCAL_ACCESS(heap.data, 31LLU, 30LLU) = 0;
5924659382 // ACCUMULATE ARGUMENTS - BEGIN
5924759383 {
59248- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 30LLU, 0LLU);
59384+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 31LLU, 0LLU);
5924959385 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5925059386 }
5925159387 {
59252- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 30LLU, 8LLU);
59388+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 31LLU, 8LLU);
5925359389 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5925459390 }
5925559391 {
59256- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 30LLU, 9LLU);
59392+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 31LLU, 9LLU);
5925759393 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5925859394 }
5925959395 {
59260- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 19LLU);
59396+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 21LLU);
5926159397 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5926259398 }
5926359399 {
59264- uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 27LLU);
59400+ uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 28LLU);
5926559401 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5926659402 }
5926759403 {
59268- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 25LLU);
59404+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 26LLU);
5926959405 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5927059406 }
5927159407 {
59272- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 22LLU);
59408+ uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 23LLU);
5927359409 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5927459410 }
5927559411 {
59276- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 24LLU);
59412+ uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 25LLU);
5927759413 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5927859414 }
5927959415 {
59280- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 26LLU);
59416+ uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 27LLU);
5928159417 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5928259418 }
5928359419 {
59284- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 23LLU);
59420+ uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 24LLU);
5928559421 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5928659422 }
5928759423 {
59288- uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 28LLU);
59424+ uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 29LLU);
5928959425 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5929059426 }
5929159427 {
59292- uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 29LLU);
59428+ uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 30LLU);
5929359429 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5929459430 }
5929559431 // ACCUMULATE ARGUMENTS - END
59296- uint64_t return_to = 18446744073709548145LLU;
59432+ uint64_t return_to = 18446744073709548129LLU;
5929759433 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
5929859434 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5929959435 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59302,36 +59438,36 @@
5930259438 state.addr = 604790753280317473LLU; // findvarref
5930359439 break;
5930459440 }
59305- case 18446744073709548145LLU: // 99999999Iv'''''''''''''''
59441+ case 18446744073709548129LLU: // 99999999If'''''''''''''''
5930659442 {
59307- state.addr = 18446744073709548146LLU; // 99999999Iw'''''''''''''''
59443+ state.addr = 18446744073709548130LLU; // 99999999Ig'''''''''''''''
5930859444 break;
5930959445 }
59310- case 18446744073709548146LLU: // 99999999Iw'''''''''''''''
59446+ case 18446744073709548130LLU: // 99999999Ig'''''''''''''''
5931159447 {
5931259448 // ACCUMULATE ARGUMENTS - BEGIN
5931359449 {
59314- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 30LLU, 12LLU);
59450+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 31LLU, 12LLU);
5931559451 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5931659452 }
5931759453 {
59318- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 30LLU, 13LLU);
59454+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 31LLU, 13LLU);
5931959455 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5932059456 }
5932159457 {
59322- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 30LLU, 14LLU);
59458+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 31LLU, 14LLU);
5932359459 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5932459460 }
5932559461 {
59326- uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 27LLU);
59462+ uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 28LLU);
5932759463 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5932859464 }
5932959465 {
59330- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 25LLU);
59466+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 31LLU, 26LLU);
5933159467 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5933259468 }
5933359469 // ACCUMULATE ARGUMENTS - END
59334- uint64_t return_to = 18446744073709548143LLU;
59470+ uint64_t return_to = 18446744073709548127LLU;
5933559471 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5933659472 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5933759473 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59340,47 +59476,47 @@
5934059476 state.addr = 587881357514113024LLU; // emitpar___
5934159477 break;
5934259478 }
59343- case 18446744073709548143LLU: // 99999999It'''''''''''''''
59479+ case 18446744073709548127LLU: // 99999999Id'''''''''''''''
5934459480 {
59345- state.addr = 18446744073709548144LLU; // 99999999Iu'''''''''''''''
59481+ state.addr = 18446744073709548128LLU; // 99999999Ie'''''''''''''''
5934659482 break;
5934759483 }
59348- case 18446744073709548144LLU: // 99999999Iu'''''''''''''''
59484+ case 18446744073709548128LLU: // 99999999Ie'''''''''''''''
5934959485 {
5935059486 // variable u64 consume___ goes out of scope
5935159487 // emitted destructur for type u64
59352- (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 30
59488+ (void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 31
5935359489 // variable u64 optelem___ goes out of scope
5935459490 // emitted destructur for type u64
59355- (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 29
59356- state.addr = 18446744073709548147LLU; // 99999999Ix'''''''''''''''
59491+ (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 30
59492+ state.addr = 18446744073709548131LLU; // 99999999Ih'''''''''''''''
5935759493 break;
5935859494 }
59359- case 18446744073709548147LLU: // 99999999Ix'''''''''''''''
59495+ case 18446744073709548131LLU: // 99999999Ih'''''''''''''''
5936059496 {
5936159497 // ACCUMULATE ARGUMENTS - BEGIN
5936259498 {
59363- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
59499+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
5936459500 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5936559501 }
5936659502 {
59367- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
59503+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 21LLU);
5936859504 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5936959505 }
5937059506 {
59371- uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 25LLU);
59507+ uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU);
5937259508 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5937359509 }
5937459510 {
59375- uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 24LLU);
59511+ uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 25LLU);
5937659512 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5937759513 }
5937859514 {
59379- uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 26LLU);
59515+ uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 27LLU);
5938059516 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5938159517 }
5938259518 // ACCUMULATE ARGUMENTS - END
59383- uint64_t return_to = 18446744073709548141LLU;
59519+ uint64_t return_to = 18446744073709548125LLU;
5938459520 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5938559521 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5938659522 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59389,37 +59525,37 @@
5938959525 state.addr = 842862227159939072LLU; // swappable_
5939059526 break;
5939159527 }
59392- case 18446744073709548141LLU: // 99999999Ir'''''''''''''''
59528+ case 18446744073709548125LLU: // 99999999Ib'''''''''''''''
5939359529 {
59394- state.addr = 18446744073709548142LLU; // 99999999Is'''''''''''''''
59530+ state.addr = 18446744073709548126LLU; // 99999999Ic'''''''''''''''
5939559531 break;
5939659532 }
59397- case 18446744073709548142LLU: // 99999999Is'''''''''''''''
59533+ case 18446744073709548126LLU: // 99999999Ic'''''''''''''''
5939859534 {
5939959535 {
5940059536 uint64_t arg = 0;
59401- LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59537+ LOCAL_PUSH_MOVE(&heap, 29, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5940259538 }
59403- *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = 819865187908583424;
59539+ *LOCAL_ACCESS(heap.data, 30LLU, 29LLU) = 819865187908583424;
5940459540 // ACCUMULATE ARGUMENTS - BEGIN
5940559541 {
59406- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
59542+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 30LLU, 0LLU);
5940759543 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5940859544 }
5940959545 {
59410- uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU);
59546+ uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 29LLU);
5941159547 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5941259548 }
5941359549 {
59414- uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU);
59550+ uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 24LLU);
5941559551 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5941659552 }
5941759553 {
59418- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU);
59554+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 21LLU);
5941959555 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5942059556 }
5942159557 // ACCUMULATE ARGUMENTS - END
59422- uint64_t return_to = 18446744073709548139LLU;
59558+ uint64_t return_to = 18446744073709548123LLU;
5942359559 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5942459560 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5942559561 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59428,32 +59564,32 @@
5942859564 state.addr = 660220410725010287LLU; // initassert
5942959565 break;
5943059566 }
59431- case 18446744073709548139LLU: // 99999999Ip'''''''''''''''
59567+ case 18446744073709548123LLU: // 99999999I$'''''''''''''''
5943259568 {
59433- state.addr = 18446744073709548140LLU; // 99999999Iq'''''''''''''''
59569+ state.addr = 18446744073709548124LLU; // 99999999Ia'''''''''''''''
5943459570 break;
5943559571 }
59436- case 18446744073709548140LLU: // 99999999Iq'''''''''''''''
59572+ case 18446744073709548124LLU: // 99999999Ia'''''''''''''''
5943759573 {
5943859574 // ACCUMULATE ARGUMENTS - BEGIN
5943959575 {
59440- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
59576+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 30LLU, 0LLU);
5944159577 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5944259578 }
5944359579 {
59444- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU);
59580+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 30LLU, 8LLU);
5944559581 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5944659582 }
5944759583 {
59448- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU);
59584+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 30LLU, 9LLU);
5944959585 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5945059586 }
5945159587 {
59452- uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU);
59588+ uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 21LLU);
5945359589 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5945459590 }
5945559591 // ACCUMULATE ARGUMENTS - END
59456- uint64_t return_to = 18446744073709548137LLU;
59592+ uint64_t return_to = 18446744073709548121LLU;
5945759593 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
5945859594 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5945959595 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59462,28 +59598,28 @@
5946259598 state.addr = 732615645798520865LLU; // movevarref
5946359599 break;
5946459600 }
59465- case 18446744073709548137LLU: // 99999999In'''''''''''''''
59601+ case 18446744073709548121LLU: // 99999999IY'''''''''''''''
5946659602 {
59467- state.addr = 18446744073709548138LLU; // 99999999Io'''''''''''''''
59603+ state.addr = 18446744073709548122LLU; // 99999999IZ'''''''''''''''
5946859604 break;
5946959605 }
59470- case 18446744073709548138LLU: // 99999999Io'''''''''''''''
59606+ case 18446744073709548122LLU: // 99999999IZ'''''''''''''''
5947159607 {
5947259608 // ACCUMULATE ARGUMENTS - BEGIN
5947359609 {
59474- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
59610+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 30LLU, 0LLU);
5947559611 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5947659612 }
5947759613 {
59478- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 0LLU);
59614+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 30LLU, 20LLU), 0LLU);
5947959615 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5948059616 }
5948159617 {
59482- uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU);
59618+ uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 30LLU, 23LLU);
5948359619 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5948459620 }
5948559621 // ACCUMULATE ARGUMENTS - END
59486- uint64_t return_to = 18446744073709548135LLU;
59622+ uint64_t return_to = 18446744073709548119LLU;
5948759623 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5948859624 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5948959625 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59492,37 +59628,37 @@
5949259628 state.addr = 861504774606556015LLU; // typeassert
5949359629 break;
5949459630 }
59495- case 18446744073709548135LLU: // 99999999Il'''''''''''''''
59631+ case 18446744073709548119LLU: // 99999999IW'''''''''''''''
5949659632 {
59497- state.addr = 18446744073709548136LLU; // 99999999Im'''''''''''''''
59633+ state.addr = 18446744073709548120LLU; // 99999999IX'''''''''''''''
5949859634 break;
5949959635 }
59500- case 18446744073709548136LLU: // 99999999Im'''''''''''''''
59636+ case 18446744073709548120LLU: // 99999999IX'''''''''''''''
5950159637 {
5950259638 fprintf(stdout, "%s", ", &");
5950359639 // ACCUMULATE ARGUMENTS - BEGIN
5950459640 {
59505- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU);
59641+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 30LLU, 12LLU);
5950659642 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5950759643 }
5950859644 {
59509- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU);
59645+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 30LLU, 13LLU);
5951059646 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5951159647 }
5951259648 {
59513- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU);
59649+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 30LLU, 14LLU);
5951459650 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5951559651 }
5951659652 {
59517- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 1LLU);
59653+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 30LLU, 20LLU), 1LLU);
5951859654 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5951959655 }
5952059656 {
59521- uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 29LLU, 18LLU), 2LLU);
59657+ uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 30LLU, 20LLU), 2LLU);
5952259658 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5952359659 }
5952459660 // ACCUMULATE ARGUMENTS - END
59525- uint64_t return_to = 18446744073709548133LLU;
59661+ uint64_t return_to = 18446744073709548117LLU;
5952659662 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5952759663 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5952859664 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59531,41 +59667,41 @@
5953159667 state.addr = 587881357514113024LLU; // emitpar___
5953259668 break;
5953359669 }
59534- case 18446744073709548133LLU: // 99999999Ij'''''''''''''''
59670+ case 18446744073709548117LLU: // 99999999IU'''''''''''''''
5953559671 {
59536- state.addr = 18446744073709548134LLU; // 99999999Ik'''''''''''''''
59672+ state.addr = 18446744073709548118LLU; // 99999999IV'''''''''''''''
5953759673 break;
5953859674 }
59539- case 18446744073709548134LLU: // 99999999Ik'''''''''''''''
59675+ case 18446744073709548118LLU: // 99999999IV'''''''''''''''
5954059676 {
5954159677 fprintf(stdout, "%s", "); // result");
5954259678 // variable u64 info______ goes out of scope
5954359679 // emitted destructur for type u64
59544- (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 29
59680+ (void)LOCAL_POP_MOVE(&heap, 30LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 30
5954559681 // variable u64 idx_______ goes out of scope
5954659682 // emitted destructur for type u64
59547- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 28
59683+ (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 29
5954859684 // variable u64 parameter_ goes out of scope
5954959685 // emitted destructur for type u64
59550- (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 27
59686+ (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 28
5955159687 // variable u64 INDIRECT__ goes out of scope
5955259688 // emitted destructur for type u64
59553- (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 26
59689+ (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 27
5955459690 // variable u64 mutable___ goes out of scope
5955559691 // emitted destructur for type u64
59556- (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 25
59692+ (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 26
5955759693 // variable u64 init1_____ goes out of scope
5955859694 // emitted destructur for type u64
59559- (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 24
59695+ (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 25
5956059696 // variable type______ typesrc___ goes out of scope
5956159697 // emitted destructur for type type______
5956259698 // ACCUMULATE ARGUMENTS - BEGIN
5956359699 {
59564- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
59700+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 24LLU, 23LLU);
5956559701 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5956659702 }
5956759703 // ACCUMULATE ARGUMENTS - END
59568- uint64_t return_to = 18446744073709548132LLU;
59704+ uint64_t return_to = 18446744073709548116LLU;
5956959705 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5957059706 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5957159707 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59574,42 +59710,39 @@
5957459710 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
5957559711 break;
5957659712 }
59577- case 18446744073709548132LLU: // 99999999Ii'''''''''''''''
59713+ case 18446744073709548116LLU: // 99999999IT'''''''''''''''
5957859714 {
59579- (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 23
59580- state.addr = 18446744073709548150LLU; // 99999999I0'''''''''''''''
59715+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 24
59716+ state.addr = 18446744073709548134LLU; // 99999999Ik'''''''''''''''
5958159717 break;
5958259718 }
59583- case 18446744073709548150LLU: // 99999999I0'''''''''''''''
59719+ case 18446744073709548134LLU: // 99999999Ik'''''''''''''''
5958459720 {
5958559721 // variable u64 called____ goes out of scope
5958659722 // emitted destructur for type u64
59587- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 22
59588- // variable u64 sym_______ goes out of scope
59589- // emitted destructur for type u64
59590- (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 21
59723+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 23
5959159724 // variable u64 id1_______ goes out of scope
5959259725 // emitted destructur for type u64
59593- (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 20
59594- state.addr = 18446744073709548162LLU; // 99999999JB'''''''''''''''
59726+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 22
59727+ state.addr = 18446744073709548146LLU; // 99999999Iw'''''''''''''''
5959559728 break;
5959659729 }
59597- case 18446744073709548162LLU: // 99999999JB'''''''''''''''
59730+ case 18446744073709548146LLU: // 99999999Iw'''''''''''''''
5959859731 {
5959959732 // parameter-reference resdest___ respar____ goes out of scope
5960059733 // parameter-reference list<resdest___> results___ goes out of scope
59601- state.addr = 18446744073709548181LLU; // 99999999JU'''''''''''''''
59734+ state.addr = 18446744073709548165LLU; // 99999999JE'''''''''''''''
5960259735 break;
5960359736 }
59604- case 18446744073709548180LLU: // 99999999JT'''''''''''''''
59737+ case 18446744073709548164LLU: // 99999999JD'''''''''''''''
5960559738 {
5960659739 // ACCUMULATE ARGUMENTS - BEGIN
5960759740 {
59608- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 17LLU, 11LLU);
59741+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 19LLU, 11LLU);
5960959742 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5961059743 }
5961159744 // ACCUMULATE ARGUMENTS - END
59612- uint64_t return_to = 18446744073709548130LLU;
59745+ uint64_t return_to = 18446744073709548114LLU;
5961359746 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5961459747 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5961559748 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59618,31 +59751,31 @@
5961859751 state.addr = 839519719621918720LLU; // skipws____
5961959752 break;
5962059753 }
59621- case 18446744073709548130LLU: // 99999999Ig'''''''''''''''
59754+ case 18446744073709548114LLU: // 99999999IR'''''''''''''''
5962259755 {
59623- state.addr = 18446744073709548131LLU; // 99999999Ih'''''''''''''''
59756+ state.addr = 18446744073709548115LLU; // 99999999IS'''''''''''''''
5962459757 break;
5962559758 }
59626- case 18446744073709548131LLU: // 99999999Ih'''''''''''''''
59759+ case 18446744073709548115LLU: // 99999999IS'''''''''''''''
5962759760 {
59628- matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)));
59761+ matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
5962959762 // variable u64 first_____ goes out of scope
5963059763 // emitted destructur for type u64
59631- (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 17
59764+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 19
5963259765 heap.availilable_size_for_dynamic_objects += 0LLU;
5963359766 heap.availilable_size_for_dynamic_objects += 0LLU;
59634- state.addr = 18446744073709548129LLU; // 99999999If'''''''''''''''
59767+ state.addr = 18446744073709548113LLU; // 99999999IQ'''''''''''''''
5963559768 break;
5963659769 }
59637- case 18446744073709548182LLU: // 99999999JV'''''''''''''''
59770+ case 18446744073709548166LLU: // 99999999JF'''''''''''''''
5963859771 {
5963959772 // ACCUMULATE ARGUMENTS - BEGIN
5964059773 {
59641- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
59774+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU);
5964259775 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5964359776 }
5964459777 // ACCUMULATE ARGUMENTS - END
59645- uint64_t return_to = 18446744073709548127LLU;
59778+ uint64_t return_to = 18446744073709548111LLU;
5964659779 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5964759780 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5964859781 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59651,28 +59784,22 @@
5965159784 state.addr = 839519719621918720LLU; // skipws____
5965259785 break;
5965359786 }
59654- case 18446744073709548127LLU: // 99999999Id'''''''''''''''
59787+ case 18446744073709548111LLU: // 99999999IO'''''''''''''''
5965559788 {
59656- state.addr = 18446744073709548128LLU; // 99999999Ie'''''''''''''''
59789+ state.addr = 18446744073709548112LLU; // 99999999IP'''''''''''''''
5965759790 break;
5965859791 }
59659- case 18446744073709548128LLU: // 99999999Ie'''''''''''''''
59792+ case 18446744073709548112LLU: // 99999999IP'''''''''''''''
5966059793 {
59661- {
59662- uint64_t arg = 0;
59663- LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59664- }
59665- *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 40;
59666- {
59667- uint64_t arg = 0;
59668- LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
59669- }
59670- *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = 0;
59794+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = 40LLU;
59795+
59796+ *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = 0LLU;
59797+
5967159798 /*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));
59672- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548126LLU : 18446744073709548125LLU;
59799+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709548110LLU : 18446744073709548109LLU;
5967359800 break;
5967459801 }
59675- case 18446744073709548126LLU: // 99999999Ic'''''''''''''''
59802+ case 18446744073709548110LLU: // 99999999IN'''''''''''''''
5967659803 {
5967759804 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
5967859805 // ACCUMULATE ARGUMENTS - BEGIN
@@ -59681,7 +59808,7 @@
5968159808 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5968259809 }
5968359810 // ACCUMULATE ARGUMENTS - END
59684- uint64_t return_to = 18446744073709548123LLU;
59811+ uint64_t return_to = 18446744073709548107LLU;
5968559812 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5968659813 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5968759814 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59690,37 +59817,36 @@
5969059817 state.addr = 839519719621918720LLU; // skipws____
5969159818 break;
5969259819 }
59693- case 18446744073709548123LLU: // 99999999I$'''''''''''''''
59820+ case 18446744073709548107LLU: // 99999999IK'''''''''''''''
5969459821 {
59695- state.addr = 18446744073709548124LLU; // 99999999Ia'''''''''''''''
59822+ state.addr = 18446744073709548108LLU; // 99999999IL'''''''''''''''
5969659823 break;
5969759824 }
59698- case 18446744073709548124LLU: // 99999999Ia'''''''''''''''
59825+ case 18446744073709548108LLU: // 99999999IL'''''''''''''''
5969959826 {
5970059827 matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
59701- state.addr = 18446744073709548125LLU; // 99999999Ib'''''''''''''''
59828+ state.addr = 18446744073709548109LLU; // 99999999IM'''''''''''''''
5970259829 break;
5970359830 }
59704- case 18446744073709548125LLU: // 99999999Ib'''''''''''''''
59831+ case 18446744073709548109LLU: // 99999999IM'''''''''''''''
5970559832 {
59706- // variable u64 matchsym__ goes out of scope
59707- // emitted destructur for type u64
59708- (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference matchsym__ at 18
59709- // variable u64 sym_______ goes out of scope
59710- // emitted destructur for type u64
59711- (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 17
59712- state.addr = 18446744073709548129LLU; // 99999999If'''''''''''''''
59833+ state.addr = 18446744073709548113LLU; // 99999999IQ'''''''''''''''
5971359834 break;
5971459835 }
59715- case 18446744073709548129LLU: // 99999999If'''''''''''''''
59836+ case 18446744073709548113LLU: // 99999999IQ'''''''''''''''
5971659837 {
59838+ state.addr = 18446744073709548168LLU; // 99999999JH'''''''''''''''
59839+ break;
59840+ }
59841+ case 18446744073709548168LLU: // 99999999JH'''''''''''''''
59842+ {
5971759843 // ACCUMULATE ARGUMENTS - BEGIN
5971859844 {
59719- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
59845+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU);
5972059846 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5972159847 }
5972259848 // ACCUMULATE ARGUMENTS - END
59723- uint64_t return_to = 18446744073709548121LLU;
59849+ uint64_t return_to = 18446744073709548105LLU;
5972459850 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5972559851 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5972659852 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59729,61 +59855,61 @@
5972959855 state.addr = 839519719621918720LLU; // skipws____
5973059856 break;
5973159857 }
59732- case 18446744073709548121LLU: // 99999999IY'''''''''''''''
59858+ case 18446744073709548105LLU: // 99999999II'''''''''''''''
5973359859 {
59734- state.addr = 18446744073709548122LLU; // 99999999IZ'''''''''''''''
59860+ state.addr = 18446744073709548106LLU; // 99999999IJ'''''''''''''''
5973559861 break;
5973659862 }
59737- case 18446744073709548122LLU: // 99999999IZ'''''''''''''''
59863+ case 18446744073709548106LLU: // 99999999IJ'''''''''''''''
5973859864 {
59739- matchid("}", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 11LLU)));
59865+ matchid("}", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
5974059866 // ACCUMULATE ARGUMENTS - BEGIN
5974159867 {
59742- uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 16LLU, 1LLU);
59868+ uint64_t arg = /*tmpaddr___*/*LOCAL_ACCESS(heap.data, 18LLU, 1LLU);
5974359869 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5974459870 }
5974559871 {
59746- uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 16LLU, 7LLU);
59872+ uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 18LLU, 7LLU);
5974759873 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5974859874 }
5974959875 {
59750- uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 16LLU, 0LLU);
59876+ uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 18LLU, 0LLU);
5975159877 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5975259878 }
5975359879 {
59754- uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);
59880+ uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 18LLU, 11LLU);
5975559881 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5975659882 }
5975759883 {
59758- uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 16LLU, 8LLU);
59884+ uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 18LLU, 8LLU);
5975959885 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5976059886 }
5976159887 {
59762- uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 16LLU, 12LLU);
59888+ uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 18LLU, 12LLU);
5976359889 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5976459890 }
5976559891 {
59766- uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 16LLU, 13LLU);
59892+ uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 18LLU, 13LLU);
5976759893 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5976859894 }
5976959895 {
59770- uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU);
59896+ uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 18LLU, 14LLU);
5977159897 LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5977259898 }
5977359899 {
59774- uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
59900+ uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU);
5977559901 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5977659902 }
5977759903 {
59778- uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 16LLU, 9LLU);
59904+ uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 18LLU, 9LLU);
5977959905 LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5978059906 }
5978159907 {
59782- uint64_t arg = /*results___*/*LOCAL_ACCESS(heap.data, 16LLU, 10LLU);
59908+ uint64_t arg = /*results___*/*LOCAL_ACCESS(heap.data, 18LLU, 10LLU);
5978359909 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5978459910 }
5978559911 // ACCUMULATE ARGUMENTS - END
59786- uint64_t return_to = 18446744073709548119LLU;
59912+ uint64_t return_to = 18446744073709548103LLU;
5978759913 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
5978859914 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5978959915 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59792,13 +59918,19 @@
5979259918 state.addr = 533581901720365984LLU; // blockclose
5979359919 break;
5979459920 }
59795- case 18446744073709548119LLU: // 99999999IW'''''''''''''''
59921+ case 18446744073709548103LLU: // 99999999IG'''''''''''''''
5979659922 {
59797- state.addr = 18446744073709548120LLU; // 99999999IX'''''''''''''''
59923+ state.addr = 18446744073709548104LLU; // 99999999IH'''''''''''''''
5979859924 break;
5979959925 }
59800- case 18446744073709548120LLU: // 99999999IX'''''''''''''''
59926+ case 18446744073709548104LLU: // 99999999IH'''''''''''''''
5980159927 {
59928+ // variable u64 matchsym__ goes out of scope
59929+ // emitted destructur for type u64
59930+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference matchsym__ at 18
59931+ // variable u64 sym_______ goes out of scope
59932+ // emitted destructur for type u64
59933+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 17
5980259934 // parameter-reference u64 remainheap goes out of scope
5980359935 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainheap at 16
5980459936 // parameter-reference u64 remainsize goes out of scope
@@ -59847,7 +59979,7 @@
5984759979 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5984859980 }
5984959981 // ACCUMULATE ARGUMENTS - END
59850- uint64_t return_to = 18446744073709548117LLU;
59982+ uint64_t return_to = 18446744073709548101LLU;
5985159983 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5985259984 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5985359985 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59856,12 +59988,12 @@
5985659988 state.addr = 839519719621918720LLU; // skipws____
5985759989 break;
5985859990 }
59859- case 18446744073709548117LLU: // 99999999IU'''''''''''''''
59991+ case 18446744073709548101LLU: // 99999999IE'''''''''''''''
5986059992 {
59861- state.addr = 18446744073709548118LLU; // 99999999IV'''''''''''''''
59993+ state.addr = 18446744073709548102LLU; // 99999999IF'''''''''''''''
5986259994 break;
5986359995 }
59864- case 18446744073709548118LLU: // 99999999IV'''''''''''''''
59996+ case 18446744073709548102LLU: // 99999999IF'''''''''''''''
5986559997 {
5986659998 {
5986759999 uint64_t arg = 0;
@@ -59892,7 +60024,7 @@
5989260024 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5989360025 }
5989460026 // ACCUMULATE ARGUMENTS - END
59895- uint64_t return_to = 18446744073709548112LLU;
60027+ uint64_t return_to = 18446744073709548096LLU;
5989660028 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5989760029 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5989860030 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59901,18 +60033,18 @@
5990160033 state.addr = 661605045736570880LLU; // isdigit___
5990260034 break;
5990360035 }
59904- case 18446744073709548112LLU: // 99999999IP'''''''''''''''
60036+ case 18446744073709548096LLU: // 99999999I_'''''''''''''''
5990560037 {
59906- state.addr = 18446744073709548113LLU; // 99999999IQ'''''''''''''''
60038+ state.addr = 18446744073709548097LLU; // 99999999IA'''''''''''''''
5990760039 break;
5990860040 }
59909- case 18446744073709548113LLU: // 99999999IQ'''''''''''''''
60041+ case 18446744073709548097LLU: // 99999999IA'''''''''''''''
5991060042 {
59911- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548115LLU : 18446744073709548114LLU;
60043+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548099LLU : 18446744073709548098LLU;
5991260044 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21
5991360045 break;
5991460046 }
59915- case 18446744073709548115LLU: // 99999999IS'''''''''''''''
60047+ case 18446744073709548099LLU: // 99999999IC'''''''''''''''
5991660048 {
5991760049 {
5991860050 uint64_t arg = 0;
@@ -59920,19 +60052,19 @@
5992060052 }
5992160053 *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 0;
5992260054 /*nr________*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
59923- state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548111LLU : 18446744073709548110LLU;
60055+ state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548095LLU : 18446744073709548094LLU;
5992460056 break;
5992560057 }
59926- case 18446744073709548111LLU: // 99999999IO'''''''''''''''
60058+ case 18446744073709548095LLU: // 99999999H9'''''''''''''''
5992760059 {
5992860060 {
5992960061 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU))/*list*/, 8);
5993060062 LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5993160063 }
59932- state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 16LLU)) ? 18446744073709548109LLU : 18446744073709548108LLU;
60064+ state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 16LLU)) ? 18446744073709548093LLU : 18446744073709548092LLU;
5993360065 break;
5993460066 }
59935- case 18446744073709548109LLU: // 99999999IM'''''''''''''''
60067+ case 18446744073709548093LLU: // 99999999H7'''''''''''''''
5993660068 {
5993760069 {
5993860070 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 16LLU))/*list*/, 8);
@@ -59944,7 +60076,7 @@
5994460076 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5994560077 }
5994660078 // ACCUMULATE ARGUMENTS - END
59947- uint64_t return_to = 18446744073709548106LLU;
60079+ uint64_t return_to = 18446744073709548090LLU;
5994860080 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5994960081 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5995060082 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59953,12 +60085,12 @@
5995360085 state.addr = 819847183515949359LLU; // reportinit
5995460086 break;
5995560087 }
59956- case 18446744073709548106LLU: // 99999999IJ'''''''''''''''
60088+ case 18446744073709548090LLU: // 99999999H4'''''''''''''''
5995760089 {
59958- state.addr = 18446744073709548107LLU; // 99999999IK'''''''''''''''
60090+ state.addr = 18446744073709548091LLU; // 99999999H5'''''''''''''''
5995960091 break;
5996060092 }
59961- case 18446744073709548107LLU: // 99999999IK'''''''''''''''
60093+ case 18446744073709548091LLU: // 99999999H5'''''''''''''''
5996260094 {
5996360095 fprintf(stderr, "%s", "superfluous result in assignment from ");
5996460096 fprintf(stderr, "%llu", (unsigned long long)/*nr________*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU));
@@ -59974,7 +60106,7 @@
5997460106 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5997560107 }
5997660108 // ACCUMULATE ARGUMENTS - END
59977- uint64_t return_to = 18446744073709548105LLU;
60109+ uint64_t return_to = 18446744073709548089LLU;
5997860110 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5997960111 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5998060112 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -59983,15 +60115,15 @@
5998360115 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
5998460116 break;
5998560117 }
59986- case 18446744073709548105LLU: // 99999999II'''''''''''''''
60118+ case 18446744073709548089LLU: // 99999999H3'''''''''''''''
5998760119 {
5998860120 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 23
5998960121 heap.availilable_size_for_dynamic_objects += 0LLU;
5999060122 heap.availilable_size_for_dynamic_objects += 0LLU;
59991- state.addr = 18446744073709548104LLU; // 99999999IH'''''''''''''''
60123+ state.addr = 18446744073709548088LLU; // 99999999H2'''''''''''''''
5999260124 break;
5999360125 }
59994- case 18446744073709548108LLU: // 99999999IL'''''''''''''''
60126+ case 18446744073709548092LLU: // 99999999H6'''''''''''''''
5999560127 {
5999660128 // ACCUMULATE ARGUMENTS - BEGIN
5999760129 {
@@ -60003,7 +60135,7 @@
6000360135 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6000460136 }
6000560137 // ACCUMULATE ARGUMENTS - END
60006- uint64_t return_to = 18446744073709548102LLU;
60138+ uint64_t return_to = 18446744073709548086LLU;
6000760139 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6000860140 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6000960141 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60012,12 +60144,12 @@
6001260144 state.addr = 517555565476695680LLU; // assertu64_
6001360145 break;
6001460146 }
60015- case 18446744073709548102LLU: // 99999999IF'''''''''''''''
60147+ case 18446744073709548086LLU: // 99999999H0'''''''''''''''
6001660148 {
60017- state.addr = 18446744073709548103LLU; // 99999999IG'''''''''''''''
60149+ state.addr = 18446744073709548087LLU; // 99999999H1'''''''''''''''
6001860150 break;
6001960151 }
60020- case 18446744073709548103LLU: // 99999999IG'''''''''''''''
60152+ case 18446744073709548087LLU: // 99999999H1'''''''''''''''
6002160153 {
6002260154 fprintf(stdout, "%s", "\n ");
6002360155 // ACCUMULATE ARGUMENTS - BEGIN
@@ -60042,7 +60174,7 @@
6004260174 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6004360175 }
6004460176 // ACCUMULATE ARGUMENTS - END
60045- uint64_t return_to = 18446744073709548100LLU;
60177+ uint64_t return_to = 18446744073709548084LLU;
6004660178 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6004760179 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6004860180 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60051,12 +60183,12 @@
6005160183 state.addr = 587881357514113024LLU; // emitpar___
6005260184 break;
6005360185 }
60054- case 18446744073709548100LLU: // 99999999ID'''''''''''''''
60186+ case 18446744073709548084LLU: // 99999999Hy'''''''''''''''
6005560187 {
60056- state.addr = 18446744073709548101LLU; // 99999999IE'''''''''''''''
60188+ state.addr = 18446744073709548085LLU; // 99999999Hz'''''''''''''''
6005760189 break;
6005860190 }
60059- case 18446744073709548101LLU: // 99999999IE'''''''''''''''
60191+ case 18446744073709548085LLU: // 99999999Hz'''''''''''''''
6006060192 {
6006160193 fprintf(stdout, "%s", " = ");
6006260194 fprintf(stdout, "%llu", (unsigned long long)/*nr________*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU));
@@ -60067,10 +60199,10 @@
6006760199 fprintf(stderr, "match failed at char %c\n", (char)59LLU);
6006860200 exit(-1);
6006960201 }
60070- state.addr = 18446744073709548104LLU; // 99999999IH'''''''''''''''
60202+ state.addr = 18446744073709548088LLU; // 99999999H2'''''''''''''''
6007160203 break;
6007260204 }
60073- case 18446744073709548104LLU: // 99999999IH'''''''''''''''
60205+ case 18446744073709548088LLU: // 99999999H2'''''''''''''''
6007460206 {
6007560207 // variable resdest___ result____ goes out of scope
6007660208 // emitted destructur for type resdest___
@@ -60080,7 +60212,7 @@
6008060212 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6008160213 }
6008260214 // ACCUMULATE ARGUMENTS - END
60083- uint64_t return_to = 18446744073709548099LLU;
60215+ uint64_t return_to = 18446744073709548083LLU;
6008460216 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6008560217 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6008660218 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60089,15 +60221,15 @@
6008960221 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6009060222 break;
6009160223 }
60092- case 18446744073709548099LLU: // 99999999IC'''''''''''''''
60224+ case 18446744073709548083LLU: // 99999999Hx'''''''''''''''
6009360225 {
6009460226 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 22
6009560227 heap.availilable_size_for_dynamic_objects += 0LLU;
6009660228 heap.availilable_size_for_dynamic_objects += 0LLU;
60097- state.addr = 18446744073709548098LLU; // 99999999IB'''''''''''''''
60229+ state.addr = 18446744073709548082LLU; // 99999999Hw'''''''''''''''
6009860230 break;
6009960231 }
60100- case 18446744073709548110LLU: // 99999999IN'''''''''''''''
60232+ case 18446744073709548094LLU: // 99999999H8'''''''''''''''
6010160233 {
6010260234 // ACCUMULATE ARGUMENTS - BEGIN
6010360235 {
@@ -60105,7 +60237,7 @@
6010560237 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6010660238 }
6010760239 // ACCUMULATE ARGUMENTS - END
60108- uint64_t return_to = 18446744073709548096LLU;
60240+ uint64_t return_to = 18446744073709548080LLU;
6010960241 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6011060242 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6011160243 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60114,12 +60246,12 @@
6011460246 state.addr = 819847183515949359LLU; // reportinit
6011560247 break;
6011660248 }
60117- case 18446744073709548096LLU: // 99999999I_'''''''''''''''
60249+ case 18446744073709548080LLU: // 99999999Hu'''''''''''''''
6011860250 {
60119- state.addr = 18446744073709548097LLU; // 99999999IA'''''''''''''''
60251+ state.addr = 18446744073709548081LLU; // 99999999Hv'''''''''''''''
6012060252 break;
6012160253 }
60122- case 18446744073709548097LLU: // 99999999IA'''''''''''''''
60254+ case 18446744073709548081LLU: // 99999999Hv'''''''''''''''
6012360255 {
6012460256 fprintf(stderr, "%s", "missing result in assignment from ");
6012560257 printid(stderr, /*nr________*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU));
@@ -60127,10 +60259,10 @@
6012760259 fprintf(stderr, "%s\n", "");
6012860260 exit(-1);
6012960261 }
60130- state.addr = 18446744073709548098LLU; // 99999999IB'''''''''''''''
60262+ state.addr = 18446744073709548082LLU; // 99999999Hw'''''''''''''''
6013160263 break;
6013260264 }
60133- case 18446744073709548098LLU: // 99999999IB'''''''''''''''
60265+ case 18446744073709548082LLU: // 99999999Hw'''''''''''''''
6013460266 {
6013560267 // variable u64 nr________ goes out of scope
6013660268 // emitted destructur for type u64
@@ -60137,19 +60269,19 @@
6013760269 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 21
6013860270 heap.availilable_size_for_dynamic_objects += 0LLU;
6013960271 heap.availilable_size_for_dynamic_objects += 0LLU;
60140- state.addr = 18446744073709548095LLU; // 99999999H9'''''''''''''''
60272+ state.addr = 18446744073709548079LLU; // 99999999Ht'''''''''''''''
6014160273 break;
6014260274 }
60143- case 18446744073709548114LLU: // 99999999IR'''''''''''''''
60275+ case 18446744073709548098LLU: // 99999999IB'''''''''''''''
6014460276 {
6014560277 /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
6014660278 *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 657807020572803072LLU;
6014760279
6014860280 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
60149- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548094LLU : 18446744073709548093LLU;
60281+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548078LLU : 18446744073709548077LLU;
6015060282 break;
6015160283 }
60152- case 18446744073709548094LLU: // 99999999H8'''''''''''''''
60284+ case 18446744073709548078LLU: // 99999999Hs'''''''''''''''
6015360285 {
6015460286 // ACCUMULATE ARGUMENTS - BEGIN
6015560287 {
@@ -60217,7 +60349,7 @@
6021760349 LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6021860350 }
6021960351 // ACCUMULATE ARGUMENTS - END
60220- uint64_t return_to = 18446744073709548091LLU;
60352+ uint64_t return_to = 18446744073709548075LLU;
6022160353 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0));
6022260354 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6022360355 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60226,28 +60358,28 @@
6022660358 state.addr = 787472328605827072LLU; // procif____
6022760359 break;
6022860360 }
60229- case 18446744073709548091LLU: // 99999999H5'''''''''''''''
60361+ case 18446744073709548075LLU: // 99999999Hp'''''''''''''''
6023060362 {
60231- state.addr = 18446744073709548092LLU; // 99999999H6'''''''''''''''
60363+ state.addr = 18446744073709548076LLU; // 99999999Hq'''''''''''''''
6023260364 break;
6023360365 }
60234- case 18446744073709548092LLU: // 99999999H6'''''''''''''''
60366+ case 18446744073709548076LLU: // 99999999Hq'''''''''''''''
6023560367 {
6023660368 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
6023760369 heap.availilable_size_for_dynamic_objects += 0LLU;
6023860370 heap.availilable_size_for_dynamic_objects += 0LLU;
60239- state.addr = 18446744073709548090LLU; // 99999999H4'''''''''''''''
60371+ state.addr = 18446744073709548074LLU; // 99999999Ho'''''''''''''''
6024060372 break;
6024160373 }
60242- case 18446744073709548093LLU: // 99999999H7'''''''''''''''
60374+ case 18446744073709548077LLU: // 99999999Hr'''''''''''''''
6024360375 {
6024460376 *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 512981598149279744LLU;
6024560377
6024660378 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
60247- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548089LLU : 18446744073709548088LLU;
60379+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548073LLU : 18446744073709548072LLU;
6024860380 break;
6024960381 }
60250- case 18446744073709548089LLU: // 99999999H3'''''''''''''''
60382+ case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
6025160383 {
6025260384 // ACCUMULATE ARGUMENTS - BEGIN
6025360385 {
@@ -60295,7 +60427,7 @@
6029560427 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6029660428 }
6029760429 // ACCUMULATE ARGUMENTS - END
60298- uint64_t return_to = 18446744073709548086LLU;
60430+ uint64_t return_to = 18446744073709548070LLU;
6029960431 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
6030060432 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6030160433 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60304,20 +60436,20 @@
6030460436 state.addr = 787472319973559214LLU; // procaccess
6030560437 break;
6030660438 }
60307- case 18446744073709548086LLU: // 99999999H0'''''''''''''''
60439+ case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
6030860440 {
60309- state.addr = 18446744073709548087LLU; // 99999999H1'''''''''''''''
60441+ state.addr = 18446744073709548071LLU; // 99999999Hl'''''''''''''''
6031060442 break;
6031160443 }
60312- case 18446744073709548087LLU: // 99999999H1'''''''''''''''
60444+ case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
6031360445 {
6031460446 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
6031560447 heap.availilable_size_for_dynamic_objects += 0LLU;
6031660448 heap.availilable_size_for_dynamic_objects += 0LLU;
60317- state.addr = 18446744073709548085LLU; // 99999999Hz'''''''''''''''
60449+ state.addr = 18446744073709548069LLU; // 99999999Hj'''''''''''''''
6031860450 break;
6031960451 }
60320- case 18446744073709548088LLU: // 99999999H2'''''''''''''''
60452+ case 18446744073709548072LLU: // 99999999Hm'''''''''''''''
6032160453 {
6032260454 *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = 0LLU;
6032360455
@@ -60329,7 +60461,7 @@
6032960461 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6033060462 }
6033160463 // ACCUMULATE ARGUMENTS - END
60332- uint64_t return_to = 18446744073709548083LLU;
60464+ uint64_t return_to = 18446744073709548067LLU;
6033360465 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6033460466 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6033560467 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60338,18 +60470,18 @@
6033860470 state.addr = 839519719621918720LLU; // skipws____
6033960471 break;
6034060472 }
60341- case 18446744073709548083LLU: // 99999999Hx'''''''''''''''
60473+ case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
6034260474 {
60343- state.addr = 18446744073709548084LLU; // 99999999Hy'''''''''''''''
60475+ state.addr = 18446744073709548068LLU; // 99999999Hi'''''''''''''''
6034460476 break;
6034560477 }
60346- case 18446744073709548084LLU: // 99999999Hy'''''''''''''''
60478+ case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
6034760479 {
6034860480 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU));
60349- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548082LLU : 18446744073709548081LLU;
60481+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548066LLU : 18446744073709548065LLU;
6035060482 break;
6035160483 }
60352- case 18446744073709548082LLU: // 99999999Hw'''''''''''''''
60484+ case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
6035360485 {
6035460486 // ACCUMULATE ARGUMENTS - BEGIN
6035560487 {
@@ -60421,7 +60553,7 @@
6042160553 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6042260554 }
6042360555 // ACCUMULATE ARGUMENTS - END
60424- uint64_t return_to = 18446744073709548079LLU;
60556+ uint64_t return_to = 18446744073709548063LLU;
6042560557 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6042660558 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6042760559 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60430,33 +60562,33 @@
6043060562 state.addr = 782701543315110336LLU; // parsecall_
6043160563 break;
6043260564 }
60433- case 18446744073709548079LLU: // 99999999Ht'''''''''''''''
60565+ case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
6043460566 {
60435- state.addr = 18446744073709548080LLU; // 99999999Hu'''''''''''''''
60567+ state.addr = 18446744073709548064LLU; // 99999999He'''''''''''''''
6043660568 break;
6043760569 }
60438- case 18446744073709548080LLU: // 99999999Hu'''''''''''''''
60570+ case 18446744073709548064LLU: // 99999999He'''''''''''''''
6043960571 {
6044060572 heap.availilable_size_for_dynamic_objects += 0LLU;
6044160573 heap.availilable_size_for_dynamic_objects += 0LLU;
60442- state.addr = 18446744073709548078LLU; // 99999999Hs'''''''''''''''
60574+ state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
6044360575 break;
6044460576 }
60445- case 18446744073709548081LLU: // 99999999Hv'''''''''''''''
60577+ case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
6044660578 {
60447- state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)) ? 18446744073709548077LLU : 18446744073709548076LLU;
60579+ state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU)) ? 18446744073709548061LLU : 18446744073709548060LLU;
6044860580 break;
6044960581 }
60450- case 18446744073709548077LLU: // 99999999Hr'''''''''''''''
60582+ case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
6045160583 {
6045260584 {
6045360585 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 16LLU))/*list*/, 8);
6045460586 LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6045560587 }
60456- state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548075LLU : 18446744073709548074LLU;
60588+ state.addr = /*newresults*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548059LLU : 18446744073709548058LLU;
6045760589 break;
6045860590 }
60459- case 18446744073709548075LLU: // 99999999Hp'''''''''''''''
60591+ case 18446744073709548059LLU: // 99999999H$'''''''''''''''
6046060592 {
6046160593 {
6046260594 uint64_t arg = list_pop_move(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 16LLU))/*list*/, 8);
@@ -60468,7 +60600,7 @@
6046860600 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6046960601 }
6047060602 // ACCUMULATE ARGUMENTS - END
60471- uint64_t return_to = 18446744073709548072LLU;
60603+ uint64_t return_to = 18446744073709548056LLU;
6047260604 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6047360605 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6047460606 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60477,12 +60609,12 @@
6047760609 state.addr = 819847183515949359LLU; // reportinit
6047860610 break;
6047960611 }
60480- case 18446744073709548072LLU: // 99999999Hm'''''''''''''''
60612+ case 18446744073709548056LLU: // 99999999HX'''''''''''''''
6048160613 {
60482- state.addr = 18446744073709548073LLU; // 99999999Hn'''''''''''''''
60614+ state.addr = 18446744073709548057LLU; // 99999999HY'''''''''''''''
6048360615 break;
6048460616 }
60485- case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
60617+ case 18446744073709548057LLU: // 99999999HY'''''''''''''''
6048660618 {
6048760619 fprintf(stderr, "%s", "superfluous result in assignment from ");
6048860620 printid(stderr, /*callee_id_*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU));
@@ -60498,7 +60630,7 @@
6049860630 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6049960631 }
6050060632 // ACCUMULATE ARGUMENTS - END
60501- uint64_t return_to = 18446744073709548071LLU;
60633+ uint64_t return_to = 18446744073709548055LLU;
6050260634 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6050360635 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6050460636 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60507,15 +60639,15 @@
6050760639 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6050860640 break;
6050960641 }
60510- case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
60642+ case 18446744073709548055LLU: // 99999999HW'''''''''''''''
6051160643 {
6051260644 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 22
6051360645 heap.availilable_size_for_dynamic_objects += 0LLU;
6051460646 heap.availilable_size_for_dynamic_objects += 0LLU;
60515- state.addr = 18446744073709548070LLU; // 99999999Hk'''''''''''''''
60647+ state.addr = 18446744073709548054LLU; // 99999999HV'''''''''''''''
6051660648 break;
6051760649 }
60518- case 18446744073709548074LLU: // 99999999Ho'''''''''''''''
60650+ case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
6051960651 {
6052060652 // ACCUMULATE ARGUMENTS - BEGIN
6052160653 {
@@ -60527,7 +60659,7 @@
6052760659 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6052860660 }
6052960661 // ACCUMULATE ARGUMENTS - END
60530- uint64_t return_to = 18446744073709548068LLU;
60662+ uint64_t return_to = 18446744073709548052LLU;
6053160663 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6053260664 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6053360665 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60536,12 +60668,12 @@
6053660668 state.addr = 517555565476695680LLU; // assertu64_
6053760669 break;
6053860670 }
60539- case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
60671+ case 18446744073709548052LLU: // 99999999HT'''''''''''''''
6054060672 {
60541- state.addr = 18446744073709548069LLU; // 99999999Hj'''''''''''''''
60673+ state.addr = 18446744073709548053LLU; // 99999999HU'''''''''''''''
6054260674 break;
6054360675 }
60544- case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
60676+ case 18446744073709548053LLU: // 99999999HU'''''''''''''''
6054560677 {
6054660678 fprintf(stdout, "%s", "\n ");
6054760679 // ACCUMULATE ARGUMENTS - BEGIN
@@ -60566,7 +60698,7 @@
6056660698 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6056760699 }
6056860700 // ACCUMULATE ARGUMENTS - END
60569- uint64_t return_to = 18446744073709548066LLU;
60701+ uint64_t return_to = 18446744073709548050LLU;
6057060702 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6057160703 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6057260704 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60575,12 +60707,12 @@
6057560707 state.addr = 587881357514113024LLU; // emitpar___
6057660708 break;
6057760709 }
60578- case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
60710+ case 18446744073709548050LLU: // 99999999HR'''''''''''''''
6057960711 {
60580- state.addr = 18446744073709548067LLU; // 99999999Hh'''''''''''''''
60712+ state.addr = 18446744073709548051LLU; // 99999999HS'''''''''''''''
6058160713 break;
6058260714 }
60583- case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
60715+ case 18446744073709548051LLU: // 99999999HS'''''''''''''''
6058460716 {
6058560717 fprintf(stdout, "%s", " = ");
6058660718 {
@@ -60593,7 +60725,7 @@
6059360725 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6059460726 }
6059560727 // ACCUMULATE ARGUMENTS - END
60596- uint64_t return_to = 18446744073709548064LLU;
60728+ uint64_t return_to = 18446744073709548048LLU;
6059760729 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6059860730 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6059960731 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60602,12 +60734,12 @@
6060260734 state.addr = 861504796319285248LLU; // typeu64___
6060360735 break;
6060460736 }
60605- case 18446744073709548064LLU: // 99999999He'''''''''''''''
60737+ case 18446744073709548048LLU: // 99999999HP'''''''''''''''
6060660738 {
60607- state.addr = 18446744073709548065LLU; // 99999999Hf'''''''''''''''
60739+ state.addr = 18446744073709548049LLU; // 99999999HQ'''''''''''''''
6060860740 break;
6060960741 }
60610- case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
60742+ case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
6061160743 {
6061260744 {
6061360745 uint64_t arg = 0;
@@ -60696,7 +60828,7 @@
6069660828 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6069760829 }
6069860830 // ACCUMULATE ARGUMENTS - END
60699- uint64_t return_to = 18446744073709548062LLU;
60831+ uint64_t return_to = 18446744073709548046LLU;
6070060832 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6070160833 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6070260834 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60705,12 +60837,12 @@
6070560837 state.addr = 787472342492567585LLU; // procvarref
6070660838 break;
6070760839 }
60708- case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
60840+ case 18446744073709548046LLU: // 99999999HN'''''''''''''''
6070960841 {
60710- state.addr = 18446744073709548063LLU; // 99999999Hd'''''''''''''''
60842+ state.addr = 18446744073709548047LLU; // 99999999HO'''''''''''''''
6071160843 break;
6071260844 }
60713- case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
60845+ case 18446744073709548047LLU: // 99999999HO'''''''''''''''
6071460846 {
6071560847 fprintf(stdout, "%s", ";");
6071660848 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 27LLU, 11LLU)), stdin);
@@ -60742,7 +60874,7 @@
6074260874 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6074360875 }
6074460876 // ACCUMULATE ARGUMENTS - END
60745- uint64_t return_to = 18446744073709548061LLU;
60877+ uint64_t return_to = 18446744073709548045LLU;
6074660878 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6074760879 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6074860880 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60751,13 +60883,13 @@
6075160883 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6075260884 break;
6075360885 }
60754- case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
60886+ case 18446744073709548045LLU: // 99999999HM'''''''''''''''
6075560887 {
6075660888 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 22
60757- state.addr = 18446744073709548070LLU; // 99999999Hk'''''''''''''''
60889+ state.addr = 18446744073709548054LLU; // 99999999HV'''''''''''''''
6075860890 break;
6075960891 }
60760- case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
60892+ case 18446744073709548054LLU: // 99999999HV'''''''''''''''
6076160893 {
6076260894 // variable resdest___ result____ goes out of scope
6076360895 // emitted destructur for type resdest___
@@ -60767,7 +60899,7 @@
6076760899 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6076860900 }
6076960901 // ACCUMULATE ARGUMENTS - END
60770- uint64_t return_to = 18446744073709548060LLU;
60902+ uint64_t return_to = 18446744073709548044LLU;
6077160903 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6077260904 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6077360905 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60776,15 +60908,15 @@
6077660908 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6077760909 break;
6077860910 }
60779- case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
60911+ case 18446744073709548044LLU: // 99999999HL'''''''''''''''
6078060912 {
6078160913 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 21
6078260914 heap.availilable_size_for_dynamic_objects += 0LLU;
6078360915 heap.availilable_size_for_dynamic_objects += 0LLU;
60784- state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
60916+ state.addr = 18446744073709548043LLU; // 99999999HK'''''''''''''''
6078560917 break;
6078660918 }
60787- case 18446744073709548076LLU: // 99999999Hq'''''''''''''''
60919+ case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
6078860920 {
6078960921 // ACCUMULATE ARGUMENTS - BEGIN
6079060922 {
@@ -60792,7 +60924,7 @@
6079260924 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6079360925 }
6079460926 // ACCUMULATE ARGUMENTS - END
60795- uint64_t return_to = 18446744073709548057LLU;
60927+ uint64_t return_to = 18446744073709548041LLU;
6079660928 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6079760929 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6079860930 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60801,12 +60933,12 @@
6080160933 state.addr = 819847183515949359LLU; // reportinit
6080260934 break;
6080360935 }
60804- case 18446744073709548057LLU: // 99999999HY'''''''''''''''
60936+ case 18446744073709548041LLU: // 99999999HI'''''''''''''''
6080560937 {
60806- state.addr = 18446744073709548058LLU; // 99999999HZ'''''''''''''''
60938+ state.addr = 18446744073709548042LLU; // 99999999HJ'''''''''''''''
6080760939 break;
6080860940 }
60809- case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
60941+ case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
6081060942 {
6081160943 fprintf(stderr, "%s", "missing result in assignment from ");
6081260944 printid(stderr, /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU));
@@ -60814,38 +60946,38 @@
6081460946 fprintf(stderr, "%s\n", "");
6081560947 exit(-1);
6081660948 }
60817- state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
60949+ state.addr = 18446744073709548043LLU; // 99999999HK'''''''''''''''
6081860950 break;
6081960951 }
60820- case 18446744073709548059LLU: // 99999999H$'''''''''''''''
60952+ case 18446744073709548043LLU: // 99999999HK'''''''''''''''
6082160953 {
60822- state.addr = 18446744073709548078LLU; // 99999999Hs'''''''''''''''
60954+ state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
6082360955 break;
6082460956 }
60825- case 18446744073709548078LLU: // 99999999Hs'''''''''''''''
60957+ case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
6082660958 {
60827- state.addr = 18446744073709548085LLU; // 99999999Hz'''''''''''''''
60959+ state.addr = 18446744073709548069LLU; // 99999999Hj'''''''''''''''
6082860960 break;
6082960961 }
60830- case 18446744073709548085LLU: // 99999999Hz'''''''''''''''
60962+ case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
6083160963 {
60832- state.addr = 18446744073709548090LLU; // 99999999H4'''''''''''''''
60964+ state.addr = 18446744073709548074LLU; // 99999999Ho'''''''''''''''
6083360965 break;
6083460966 }
60835- case 18446744073709548090LLU: // 99999999H4'''''''''''''''
60967+ case 18446744073709548074LLU: // 99999999Ho'''''''''''''''
6083660968 {
60837- state.addr = 18446744073709548095LLU; // 99999999H9'''''''''''''''
60969+ state.addr = 18446744073709548079LLU; // 99999999Ht'''''''''''''''
6083860970 break;
6083960971 }
60840- case 18446744073709548095LLU: // 99999999H9'''''''''''''''
60972+ case 18446744073709548079LLU: // 99999999Ht'''''''''''''''
6084160973 {
6084260974 // variable u64 callee_id_ goes out of scope
6084360975 // emitted destructur for type u64
6084460976 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference callee_id_ at 20
60845- state.addr = 18446744073709548116LLU; // 99999999IT'''''''''''''''
60977+ state.addr = 18446744073709548100LLU; // 99999999ID'''''''''''''''
6084660978 break;
6084760979 }
60848- case 18446744073709548116LLU: // 99999999IT'''''''''''''''
60980+ case 18446744073709548100LLU: // 99999999ID'''''''''''''''
6084960981 {
6085060982 // variable u64 sym_______ goes out of scope
6085160983 // emitted destructur for type u64
@@ -60907,7 +61039,7 @@
6090761039 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6090861040 }
6090961041 // ACCUMULATE ARGUMENTS - END
60910- uint64_t return_to = 18446744073709548055LLU;
61042+ uint64_t return_to = 18446744073709548039LLU;
6091161043 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6091261044 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6091361045 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -60916,12 +61048,12 @@
6091661048 state.addr = 861504796319285248LLU; // typeu64___
6091761049 break;
6091861050 }
60919- case 18446744073709548055LLU: // 99999999HW'''''''''''''''
61051+ case 18446744073709548039LLU: // 99999999HG'''''''''''''''
6092061052 {
60921- state.addr = 18446744073709548056LLU; // 99999999HX'''''''''''''''
61053+ state.addr = 18446744073709548040LLU; // 99999999HH'''''''''''''''
6092261054 break;
6092361055 }
60924- case 18446744073709548056LLU: // 99999999HX'''''''''''''''
61056+ case 18446744073709548040LLU: // 99999999HH'''''''''''''''
6092561057 {
6092661058 {
6092761059 uint64_t arg = 0;
@@ -61008,7 +61140,7 @@
6100861140 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6100961141 }
6101061142 // ACCUMULATE ARGUMENTS - END
61011- uint64_t return_to = 18446744073709548051LLU;
61143+ uint64_t return_to = 18446744073709548035LLU;
6101261144 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
6101361145 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6101461146 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61017,12 +61149,12 @@
6101761149 state.addr = 604790753280317473LLU; // findvarref
6101861150 break;
6101961151 }
61020- case 18446744073709548051LLU: // 99999999HS'''''''''''''''
61152+ case 18446744073709548035LLU: // 99999999HC'''''''''''''''
6102161153 {
61022- state.addr = 18446744073709548052LLU; // 99999999HT'''''''''''''''
61154+ state.addr = 18446744073709548036LLU; // 99999999HD'''''''''''''''
6102361155 break;
6102461156 }
61025- case 18446744073709548052LLU: // 99999999HT'''''''''''''''
61157+ case 18446744073709548036LLU: // 99999999HD'''''''''''''''
6102661158 {
6102761159 // variable u64 consume___ goes out of scope
6102861160 // emitted destructur for type u64
@@ -61030,25 +61162,25 @@
6103061162 // variable u64 optelem___ goes out of scope
6103161163 // emitted destructur for type u64
6103261164 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 20
61033- state.addr = 18446744073709548053LLU; // 99999999HU'''''''''''''''
61165+ state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
6103461166 break;
6103561167 }
61036- case 18446744073709548053LLU: // 99999999HU'''''''''''''''
61168+ case 18446744073709548037LLU: // 99999999HE'''''''''''''''
6103761169 {
61038- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548050LLU : 18446744073709548049LLU;
61170+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548034LLU : 18446744073709548033LLU;
6103961171 break;
6104061172 }
61041- case 18446744073709548050LLU: // 99999999HR'''''''''''''''
61173+ case 18446744073709548034LLU: // 99999999HB'''''''''''''''
6104261174 {
61043- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548048LLU : 18446744073709548047LLU;
61175+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548032LLU : 18446744073709548031LLU;
6104461176 break;
6104561177 }
61046- case 18446744073709548048LLU: // 99999999HP'''''''''''''''
61178+ case 18446744073709548032LLU: // 99999999H_'''''''''''''''
6104761179 {
61048- state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548046LLU : 18446744073709548045LLU;
61180+ state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548030LLU : 18446744073709548029LLU;
6104961181 break;
6105061182 }
61051- case 18446744073709548046LLU: // 99999999HN'''''''''''''''
61183+ case 18446744073709548030LLU: // 99999999G8'''''''''''''''
6105261184 {
6105361185 {
6105461186 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);
@@ -61073,7 +61205,7 @@
6107361205 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6107461206 }
6107561207 // ACCUMULATE ARGUMENTS - END
61076- uint64_t return_to = 18446744073709548043LLU;
61208+ uint64_t return_to = 18446744073709548027LLU;
6107761209 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6107861210 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6107961211 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61082,12 +61214,12 @@
6108261214 state.addr = 861504788261634048LLU; // typename__
6108361215 break;
6108461216 }
61085- case 18446744073709548043LLU: // 99999999HK'''''''''''''''
61217+ case 18446744073709548027LLU: // 99999999G5'''''''''''''''
6108661218 {
61087- state.addr = 18446744073709548044LLU; // 99999999HL'''''''''''''''
61219+ state.addr = 18446744073709548028LLU; // 99999999G6'''''''''''''''
6108861220 break;
6108961221 }
61090- case 18446744073709548044LLU: // 99999999HL'''''''''''''''
61222+ case 18446744073709548028LLU: // 99999999G6'''''''''''''''
6109161223 {
6109261224 // ACCUMULATE ARGUMENTS - BEGIN
6109361225 {
@@ -61127,7 +61259,7 @@
6112761259 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6112861260 }
6112961261 // ACCUMULATE ARGUMENTS - END
61130- uint64_t return_to = 18446744073709548041LLU;
61262+ uint64_t return_to = 18446744073709548025LLU;
6113161263 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0));
6113261264 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6113361265 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61136,12 +61268,12 @@
6113661268 state.addr = 587881344696777536LLU; // emitdestr_
6113761269 break;
6113861270 }
61139- case 18446744073709548041LLU: // 99999999HI'''''''''''''''
61271+ case 18446744073709548025LLU: // 99999999G3'''''''''''''''
6114061272 {
61141- state.addr = 18446744073709548042LLU; // 99999999HJ'''''''''''''''
61273+ state.addr = 18446744073709548026LLU; // 99999999G4'''''''''''''''
6114261274 break;
6114361275 }
61144- case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
61276+ case 18446744073709548026LLU: // 99999999G4'''''''''''''''
6114561277 {
6114661278 // variable type______ TYPEDST___ goes out of scope
6114761279 // emitted destructur for type type______
@@ -61151,7 +61283,7 @@
6115161283 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6115261284 }
6115361285 // ACCUMULATE ARGUMENTS - END
61154- uint64_t return_to = 18446744073709548040LLU;
61286+ uint64_t return_to = 18446744073709548024LLU;
6115561287 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6115661288 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6115761289 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61160,7 +61292,7 @@
6116061292 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6116161293 break;
6116261294 }
61163- case 18446744073709548040LLU: // 99999999HH'''''''''''''''
61295+ case 18446744073709548024LLU: // 99999999G2'''''''''''''''
6116461296 {
6116561297 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPEDST___ at 22
6116661298 // variable u64 name______ goes out of scope
@@ -61170,22 +61302,22 @@
6117061302 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 20
6117161303 heap.availilable_size_for_dynamic_objects += 0LLU;
6117261304 heap.availilable_size_for_dynamic_objects += 0LLU;
61173- state.addr = 18446744073709548039LLU; // 99999999HG'''''''''''''''
61305+ state.addr = 18446744073709548023LLU; // 99999999G1'''''''''''''''
6117461306 break;
6117561307 }
61176- case 18446744073709548045LLU: // 99999999HM'''''''''''''''
61308+ case 18446744073709548029LLU: // 99999999G7'''''''''''''''
6117761309 {
61178- state.addr = 18446744073709548039LLU; // 99999999HG'''''''''''''''
61310+ state.addr = 18446744073709548023LLU; // 99999999G1'''''''''''''''
6117961311 break;
6118061312 }
61181- case 18446744073709548039LLU: // 99999999HG'''''''''''''''
61313+ case 18446744073709548023LLU: // 99999999G1'''''''''''''''
6118261314 {
6118361315 heap.availilable_size_for_dynamic_objects += 0LLU;
6118461316 heap.availilable_size_for_dynamic_objects += 0LLU;
61185- state.addr = 18446744073709548038LLU; // 99999999HF'''''''''''''''
61317+ state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
6118661318 break;
6118761319 }
61188- case 18446744073709548047LLU: // 99999999HO'''''''''''''''
61320+ case 18446744073709548031LLU: // 99999999G9'''''''''''''''
6118961321 {
6119061322 fprintf(stderr, "%s", "cannot assign to constant ");
6119161323 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61194,7 +61326,7 @@
6119461326 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6119561327 }
6119661328 // ACCUMULATE ARGUMENTS - END
61197- uint64_t return_to = 18446744073709548036LLU;
61329+ uint64_t return_to = 18446744073709548020LLU;
6119861330 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6119961331 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6120061332 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61203,12 +61335,12 @@
6120361335 state.addr = 819847183518878432LLU; // reporttype
6120461336 break;
6120561337 }
61206- case 18446744073709548036LLU: // 99999999HD'''''''''''''''
61338+ case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
6120761339 {
61208- state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
61340+ state.addr = 18446744073709548021LLU; // 99999999Gz'''''''''''''''
6120961341 break;
6121061342 }
61211- case 18446744073709548037LLU: // 99999999HE'''''''''''''''
61343+ case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
6121261344 {
6121361345 fprintf(stderr, "%s", " ");
6121461346 printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
@@ -61216,17 +61348,17 @@
6121661348 fprintf(stderr, "%s\n", "");
6121761349 exit(-1);
6121861350 }
61219- state.addr = 18446744073709548038LLU; // 99999999HF'''''''''''''''
61351+ state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
6122061352 break;
6122161353 }
61222- case 18446744073709548038LLU: // 99999999HF'''''''''''''''
61354+ case 18446744073709548022LLU: // 99999999G0'''''''''''''''
6122361355 {
6122461356 heap.availilable_size_for_dynamic_objects += 0LLU;
6122561357 heap.availilable_size_for_dynamic_objects += 0LLU;
61226- state.addr = 18446744073709548035LLU; // 99999999HC'''''''''''''''
61358+ state.addr = 18446744073709548019LLU; // 99999999Gx'''''''''''''''
6122761359 break;
6122861360 }
61229- case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
61361+ case 18446744073709548033LLU: // 99999999HA'''''''''''''''
6123061362 {
6123161363 // ACCUMULATE ARGUMENTS - BEGIN
6123261364 {
@@ -61246,7 +61378,7 @@
6124661378 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6124761379 }
6124861380 // ACCUMULATE ARGUMENTS - END
61249- uint64_t return_to = 18446744073709548033LLU;
61381+ uint64_t return_to = 18446744073709548017LLU;
6125061382 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6125161383 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6125261384 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61255,17 +61387,17 @@
6125561387 state.addr = 660220432971388961LLU; // initvarref
6125661388 break;
6125761389 }
61258- case 18446744073709548033LLU: // 99999999HA'''''''''''''''
61390+ case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
6125961391 {
61260- state.addr = 18446744073709548034LLU; // 99999999HB'''''''''''''''
61392+ state.addr = 18446744073709548018LLU; // 99999999Gw'''''''''''''''
6126161393 break;
6126261394 }
61263- case 18446744073709548034LLU: // 99999999HB'''''''''''''''
61395+ case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
6126461396 {
61265- state.addr = 18446744073709548035LLU; // 99999999HC'''''''''''''''
61397+ state.addr = 18446744073709548019LLU; // 99999999Gx'''''''''''''''
6126661398 break;
6126761399 }
61268- case 18446744073709548035LLU: // 99999999HC'''''''''''''''
61400+ case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
6126961401 {
6127061402 // variable u64 parameter_ goes out of scope
6127161403 // emitted destructur for type u64
@@ -61273,10 +61405,10 @@
6127361405 // variable u64 mutable___ goes out of scope
6127461406 // emitted destructur for type u64
6127561407 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 18
61276- state.addr = 18446744073709548054LLU; // 99999999HV'''''''''''''''
61408+ state.addr = 18446744073709548038LLU; // 99999999HF'''''''''''''''
6127761409 break;
6127861410 }
61279- case 18446744073709548054LLU: // 99999999HV'''''''''''''''
61411+ case 18446744073709548038LLU: // 99999999HF'''''''''''''''
6128061412 {
6128161413 // ACCUMULATE ARGUMENTS - BEGIN
6128261414 {
@@ -61284,7 +61416,7 @@
6128461416 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6128561417 }
6128661418 // ACCUMULATE ARGUMENTS - END
61287- uint64_t return_to = 18446744073709548031LLU;
61419+ uint64_t return_to = 18446744073709548015LLU;
6128861420 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6128961421 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6129061422 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61293,12 +61425,12 @@
6129361425 state.addr = 839519719621918720LLU; // skipws____
6129461426 break;
6129561427 }
61296- case 18446744073709548031LLU: // 99999999G9'''''''''''''''
61428+ case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
6129761429 {
61298- state.addr = 18446744073709548032LLU; // 99999999H_'''''''''''''''
61430+ state.addr = 18446744073709548016LLU; // 99999999Gu'''''''''''''''
6129961431 break;
6130061432 }
61301- case 18446744073709548032LLU: // 99999999H_'''''''''''''''
61433+ case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
6130261434 {
6130361435 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 8LLU)));
6130461436 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61307,7 +61439,7 @@
6130761439 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6130861440 }
6130961441 // ACCUMULATE ARGUMENTS - END
61310- uint64_t return_to = 18446744073709548029LLU;
61442+ uint64_t return_to = 18446744073709548013LLU;
6131161443 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6131261444 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6131361445 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61316,12 +61448,12 @@
6131661448 state.addr = 839519719621918720LLU; // skipws____
6131761449 break;
6131861450 }
61319- case 18446744073709548029LLU: // 99999999G7'''''''''''''''
61451+ case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
6132061452 {
61321- state.addr = 18446744073709548030LLU; // 99999999G8'''''''''''''''
61453+ state.addr = 18446744073709548014LLU; // 99999999Gs'''''''''''''''
6132261454 break;
6132361455 }
61324- case 18446744073709548030LLU: // 99999999G8'''''''''''''''
61456+ case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
6132561457 {
6132661458 {
6132761459 uint64_t arg = 0;
@@ -61347,7 +61479,7 @@
6134761479 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6134861480 }
6134961481 // ACCUMULATE ARGUMENTS - END
61350- uint64_t return_to = 18446744073709548027LLU;
61482+ uint64_t return_to = 18446744073709548011LLU;
6135161483 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6135261484 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6135361485 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61356,17 +61488,17 @@
6135661488 state.addr = 728666047794575267LLU; // matchoptch
6135761489 break;
6135861490 }
61359- case 18446744073709548027LLU: // 99999999G5'''''''''''''''
61491+ case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
6136061492 {
61361- state.addr = 18446744073709548028LLU; // 99999999G6'''''''''''''''
61493+ state.addr = 18446744073709548012LLU; // 99999999Gq'''''''''''''''
6136261494 break;
6136361495 }
61364- case 18446744073709548028LLU: // 99999999G6'''''''''''''''
61496+ case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
6136561497 {
61366- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548026LLU : 18446744073709548025LLU;
61498+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548010LLU : 18446744073709548009LLU;
6136761499 break;
6136861500 }
61369- case 18446744073709548026LLU: // 99999999G4'''''''''''''''
61501+ case 18446744073709548010LLU: // 99999999Go'''''''''''''''
6137061502 {
6137161503 // ACCUMULATE ARGUMENTS - BEGIN
6137261504 {
@@ -61378,7 +61510,7 @@
6137861510 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6137961511 }
6138061512 // ACCUMULATE ARGUMENTS - END
61381- uint64_t return_to = 18446744073709548023LLU;
61513+ uint64_t return_to = 18446744073709548007LLU;
6138261514 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6138361515 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6138461516 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61387,17 +61519,17 @@
6138761519 state.addr = 517555565476695680LLU; // assertu64_
6138861520 break;
6138961521 }
61390- case 18446744073709548023LLU: // 99999999G1'''''''''''''''
61522+ case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
6139161523 {
61392- state.addr = 18446744073709548024LLU; // 99999999G2'''''''''''''''
61524+ state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
6139361525 break;
6139461526 }
61395- case 18446744073709548024LLU: // 99999999G2'''''''''''''''
61527+ case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
6139661528 {
61397- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548022LLU : 18446744073709548021LLU;
61529+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548006LLU : 18446744073709548005LLU;
6139861530 break;
6139961531 }
61400- case 18446744073709548022LLU: // 99999999G0'''''''''''''''
61532+ case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
6140161533 {
6140261534 fprintf(stdout, "%s", "\n ");
6140361535 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61422,7 +61554,7 @@
6142261554 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6142361555 }
6142461556 // ACCUMULATE ARGUMENTS - END
61425- uint64_t return_to = 18446744073709548019LLU;
61557+ uint64_t return_to = 18446744073709548003LLU;
6142661558 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6142761559 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6142861560 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61431,12 +61563,12 @@
6143161563 state.addr = 587881357514113024LLU; // emitpar___
6143261564 break;
6143361565 }
61434- case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
61566+ case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
6143561567 {
61436- state.addr = 18446744073709548020LLU; // 99999999Gy'''''''''''''''
61568+ state.addr = 18446744073709548004LLU; // 99999999Gi'''''''''''''''
6143761569 break;
6143861570 }
61439- case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
61571+ case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
6144061572 {
6144161573 fprintf(stdout, "%s", " = 0;");
6144261574 // ACCUMULATE ARGUMENTS - BEGIN
@@ -61457,7 +61589,7 @@
6145761589 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6145861590 }
6145961591 // ACCUMULATE ARGUMENTS - END
61460- uint64_t return_to = 18446744073709548017LLU;
61592+ uint64_t return_to = 18446744073709548001LLU;
6146161593 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6146261594 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6146361595 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61466,31 +61598,31 @@
6146661598 state.addr = 732615645798520865LLU; // movevarref
6146761599 break;
6146861600 }
61469- case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
61601+ case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
6147061602 {
61471- state.addr = 18446744073709548018LLU; // 99999999Gw'''''''''''''''
61603+ state.addr = 18446744073709548002LLU; // 99999999Gg'''''''''''''''
6147261604 break;
6147361605 }
61474- case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
61606+ case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
6147561607 {
6147661608 heap.availilable_size_for_dynamic_objects += 0LLU;
6147761609 heap.availilable_size_for_dynamic_objects += 0LLU;
61478- state.addr = 18446744073709548016LLU; // 99999999Gu'''''''''''''''
61610+ state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
6147961611 break;
6148061612 }
61481- case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
61613+ case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
6148261614 {
61483- state.addr = 18446744073709548016LLU; // 99999999Gu'''''''''''''''
61615+ state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
6148461616 break;
6148561617 }
61486- case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
61618+ case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
6148761619 {
6148861620 heap.availilable_size_for_dynamic_objects += 0LLU;
6148961621 heap.availilable_size_for_dynamic_objects += 0LLU;
61490- state.addr = 18446744073709548015LLU; // 99999999Gt'''''''''''''''
61622+ state.addr = 18446744073709547999LLU; // 99999999Gd'''''''''''''''
6149161623 break;
6149261624 }
61493- case 18446744073709548025LLU: // 99999999G3'''''''''''''''
61625+ case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
6149461626 {
6149561627 {
6149661628 uint64_t arg = 0;
@@ -61506,7 +61638,7 @@
6150661638 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6150761639 }
6150861640 // ACCUMULATE ARGUMENTS - END
61509- uint64_t return_to = 18446744073709548011LLU;
61641+ uint64_t return_to = 18446744073709547995LLU;
6151061642 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6151161643 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6151261644 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61515,23 +61647,23 @@
6151561647 state.addr = 661605045736570880LLU; // isdigit___
6151661648 break;
6151761649 }
61518- case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
61650+ case 18446744073709547995LLU: // 99999999G$'''''''''''''''
6151961651 {
61520- state.addr = 18446744073709548012LLU; // 99999999Gq'''''''''''''''
61652+ state.addr = 18446744073709547996LLU; // 99999999Ga'''''''''''''''
6152161653 break;
6152261654 }
61523- case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
61655+ case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
6152461656 {
61525- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548014LLU : 18446744073709548013LLU;
61657+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547998LLU : 18446744073709547997LLU;
6152661658 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20
6152761659 break;
6152861660 }
61529- case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
61661+ case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
6153061662 {
61531- state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548010LLU : 18446744073709548009LLU;
61663+ state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709547994LLU : 18446744073709547993LLU;
6153261664 break;
6153361665 }
61534- case 18446744073709548010LLU: // 99999999Go'''''''''''''''
61666+ case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
6153561667 {
6153661668 // ACCUMULATE ARGUMENTS - BEGIN
6153761669 {
@@ -61555,7 +61687,7 @@
6155561687 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6155661688 }
6155761689 // ACCUMULATE ARGUMENTS - END
61558- uint64_t return_to = 18446744073709548007LLU;
61690+ uint64_t return_to = 18446744073709547991LLU;
6155961691 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6156061692 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6156161693 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61564,12 +61696,12 @@
6156461696 state.addr = 587881357514113024LLU; // emitpar___
6156561697 break;
6156661698 }
61567- case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
61699+ case 18446744073709547991LLU: // 99999999GW'''''''''''''''
6156861700 {
61569- state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
61701+ state.addr = 18446744073709547992LLU; // 99999999GX'''''''''''''''
6157061702 break;
6157161703 }
61572- case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
61704+ case 18446744073709547992LLU: // 99999999GX'''''''''''''''
6157361705 {
6157461706 fprintf(stdout, "%s", " = ");
6157561707 {
@@ -61584,7 +61716,7 @@
6158461716 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6158561717 }
6158661718 // ACCUMULATE ARGUMENTS - END
61587- uint64_t return_to = 18446744073709548005LLU;
61719+ uint64_t return_to = 18446744073709547989LLU;
6158861720 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6158961721 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6159061722 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61593,12 +61725,12 @@
6159361725 state.addr = 787446708198178816LLU; // printnr___
6159461726 break;
6159561727 }
61596- case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
61728+ case 18446744073709547989LLU: // 99999999GU'''''''''''''''
6159761729 {
61598- state.addr = 18446744073709548006LLU; // 99999999Gk'''''''''''''''
61730+ state.addr = 18446744073709547990LLU; // 99999999GV'''''''''''''''
6159961731 break;
6160061732 }
61601- case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
61733+ case 18446744073709547990LLU: // 99999999GV'''''''''''''''
6160261734 {
6160361735 fprintf(stdout, "%s", ";\n");
6160461736 // variable u64 nr________ goes out of scope
@@ -61606,10 +61738,10 @@
6160661738 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 20
6160761739 heap.availilable_size_for_dynamic_objects += 0LLU;
6160861740 heap.availilable_size_for_dynamic_objects += 0LLU;
61609- state.addr = 18446744073709548004LLU; // 99999999Gi'''''''''''''''
61741+ state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
6161061742 break;
6161161743 }
61612- case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
61744+ case 18446744073709547993LLU: // 99999999GY'''''''''''''''
6161361745 {
6161461746 {
6161561747 uint64_t arg = 0;
@@ -61617,10 +61749,10 @@
6161761749 }
6161861750 *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
6161961751 /*nr________*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 8LLU)));
61620- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548003LLU : 18446744073709548002LLU;
61752+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547987LLU : 18446744073709547986LLU;
6162161753 break;
6162261754 }
61623- case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
61755+ case 18446744073709547987LLU: // 99999999GS'''''''''''''''
6162461756 {
6162561757 // ACCUMULATE ARGUMENTS - BEGIN
6162661758 {
@@ -61632,7 +61764,7 @@
6163261764 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6163361765 }
6163461766 // ACCUMULATE ARGUMENTS - END
61635- uint64_t return_to = 18446744073709548000LLU;
61767+ uint64_t return_to = 18446744073709547984LLU;
6163661768 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6163761769 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6163861770 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61641,22 +61773,22 @@
6164161773 state.addr = 517555565476695680LLU; // assertu64_
6164261774 break;
6164361775 }
61644- case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
61776+ case 18446744073709547984LLU: // 99999999GP'''''''''''''''
6164561777 {
61646- state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
61778+ state.addr = 18446744073709547985LLU; // 99999999GQ'''''''''''''''
6164761779 break;
6164861780 }
61649- case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
61781+ case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
6165061782 {
61651- state.addr = 18446744073709548002LLU; // 99999999Gg'''''''''''''''
61783+ state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
6165261784 break;
6165361785 }
61654- case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
61786+ case 18446744073709547986LLU: // 99999999GR'''''''''''''''
6165561787 {
61656- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709547999LLU : 18446744073709547998LLU;
61788+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709547983LLU : 18446744073709547982LLU;
6165761789 break;
6165861790 }
61659- case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
61791+ case 18446744073709547983LLU: // 99999999GO'''''''''''''''
6166061792 {
6166161793 // ACCUMULATE ARGUMENTS - BEGIN
6166261794 {
@@ -61676,7 +61808,7 @@
6167661808 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6167761809 }
6167861810 // ACCUMULATE ARGUMENTS - END
61679- uint64_t return_to = 18446744073709547996LLU;
61811+ uint64_t return_to = 18446744073709547980LLU;
6168061812 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6168161813 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6168261814 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61685,44 +61817,44 @@
6168561817 state.addr = 732615645798520865LLU; // movevarref
6168661818 break;
6168761819 }
61688- case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
61820+ case 18446744073709547980LLU: // 99999999GL'''''''''''''''
6168961821 {
61690- state.addr = 18446744073709547997LLU; // 99999999Gb'''''''''''''''
61822+ state.addr = 18446744073709547981LLU; // 99999999GM'''''''''''''''
6169161823 break;
6169261824 }
61693- case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
61825+ case 18446744073709547981LLU: // 99999999GM'''''''''''''''
6169461826 {
6169561827 heap.availilable_size_for_dynamic_objects += 0LLU;
6169661828 heap.availilable_size_for_dynamic_objects += 0LLU;
61697- state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
61829+ state.addr = 18446744073709547979LLU; // 99999999GK'''''''''''''''
6169861830 break;
6169961831 }
61700- case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
61832+ case 18446744073709547982LLU: // 99999999GN'''''''''''''''
6170161833 {
61702- state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
61834+ state.addr = 18446744073709547979LLU; // 99999999GK'''''''''''''''
6170361835 break;
6170461836 }
61705- case 18446744073709547995LLU: // 99999999G$'''''''''''''''
61837+ case 18446744073709547979LLU: // 99999999GK'''''''''''''''
6170661838 {
6170761839 // variable u64 nr________ goes out of scope
6170861840 // emitted destructur for type u64
6170961841 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 20
61710- state.addr = 18446744073709548004LLU; // 99999999Gi'''''''''''''''
61842+ state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
6171161843 break;
6171261844 }
61713- case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
61845+ case 18446744073709547988LLU: // 99999999GT'''''''''''''''
6171461846 {
6171561847 heap.availilable_size_for_dynamic_objects += 0LLU;
6171661848 heap.availilable_size_for_dynamic_objects += 0LLU;
61717- state.addr = 18446744073709547994LLU; // 99999999GZ'''''''''''''''
61849+ state.addr = 18446744073709547978LLU; // 99999999GJ'''''''''''''''
6171861850 break;
6171961851 }
61720- case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
61852+ case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
6172161853 {
61722- state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709547993LLU : 18446744073709547992LLU;
61854+ state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709547977LLU : 18446744073709547976LLU;
6172361855 break;
6172461856 }
61725- case 18446744073709547993LLU: // 99999999GY'''''''''''''''
61857+ case 18446744073709547977LLU: // 99999999GI'''''''''''''''
6172661858 {
6172761859 // ACCUMULATE ARGUMENTS - BEGIN
6172861860 {
@@ -61730,7 +61862,7 @@
6173061862 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6173161863 }
6173261864 // ACCUMULATE ARGUMENTS - END
61733- uint64_t return_to = 18446744073709547990LLU;
61865+ uint64_t return_to = 18446744073709547974LLU;
6173461866 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6173561867 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6173661868 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61739,12 +61871,12 @@
6173961871 state.addr = 819847183515949359LLU; // reportinit
6174061872 break;
6174161873 }
61742- case 18446744073709547990LLU: // 99999999GV'''''''''''''''
61874+ case 18446744073709547974LLU: // 99999999GF'''''''''''''''
6174361875 {
61744- state.addr = 18446744073709547991LLU; // 99999999GW'''''''''''''''
61876+ state.addr = 18446744073709547975LLU; // 99999999GG'''''''''''''''
6174561877 break;
6174661878 }
61747- case 18446744073709547991LLU: // 99999999GW'''''''''''''''
61879+ case 18446744073709547975LLU: // 99999999GG'''''''''''''''
6174861880 {
6174961881 {
6175061882 fprintf(stderr, "%s\n", "assignment to list not implemeted yet");
@@ -61752,10 +61884,10 @@
6175261884 }
6175361885 heap.availilable_size_for_dynamic_objects += 0LLU;
6175461886 heap.availilable_size_for_dynamic_objects += 0LLU;
61755- state.addr = 18446744073709547989LLU; // 99999999GU'''''''''''''''
61887+ state.addr = 18446744073709547973LLU; // 99999999GE'''''''''''''''
6175661888 break;
6175761889 }
61758- case 18446744073709547992LLU: // 99999999GX'''''''''''''''
61890+ case 18446744073709547976LLU: // 99999999GH'''''''''''''''
6175961891 {
6176061892 {
6176161893 uint64_t arg = 0;
@@ -61768,7 +61900,7 @@
6176861900 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6176961901 }
6177061902 // ACCUMULATE ARGUMENTS - END
61771- uint64_t return_to = 18446744073709547987LLU;
61903+ uint64_t return_to = 18446744073709547971LLU;
6177261904 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6177361905 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6177461906 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61777,12 +61909,12 @@
6177761909 state.addr = 839519719621918720LLU; // skipws____
6177861910 break;
6177961911 }
61780- case 18446744073709547987LLU: // 99999999GS'''''''''''''''
61912+ case 18446744073709547971LLU: // 99999999GC'''''''''''''''
6178161913 {
61782- state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
61914+ state.addr = 18446744073709547972LLU; // 99999999GD'''''''''''''''
6178361915 break;
6178461916 }
61785- case 18446744073709547988LLU: // 99999999GT'''''''''''''''
61917+ case 18446744073709547972LLU: // 99999999GD'''''''''''''''
6178661918 {
6178761919 /*srcid_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 8LLU)));
6178861920 {
@@ -61809,7 +61941,7 @@
6180961941 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6181061942 }
6181161943 // ACCUMULATE ARGUMENTS - END
61812- uint64_t return_to = 18446744073709547985LLU;
61944+ uint64_t return_to = 18446744073709547969LLU;
6181361945 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6181461946 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6181561947 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61818,17 +61950,17 @@
6181861950 state.addr = 728666047794575267LLU; // matchoptch
6181961951 break;
6182061952 }
61821- case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
61953+ case 18446744073709547969LLU: // 99999999GA'''''''''''''''
6182261954 {
61823- state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
61955+ state.addr = 18446744073709547970LLU; // 99999999GB'''''''''''''''
6182461956 break;
6182561957 }
61826- case 18446744073709547986LLU: // 99999999GR'''''''''''''''
61958+ case 18446744073709547970LLU: // 99999999GB'''''''''''''''
6182761959 {
61828- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547984LLU : 18446744073709547983LLU;
61960+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547968LLU : 18446744073709547967LLU;
6182961961 break;
6183061962 }
61831- case 18446744073709547984LLU: // 99999999GP'''''''''''''''
61963+ case 18446744073709547968LLU: // 99999999G_'''''''''''''''
6183261964 {
6183361965 // ACCUMULATE ARGUMENTS - BEGIN
6183461966 {
@@ -61836,7 +61968,7 @@
6183661968 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6183761969 }
6183861970 // ACCUMULATE ARGUMENTS - END
61839- uint64_t return_to = 18446744073709547981LLU;
61971+ uint64_t return_to = 18446744073709547965LLU;
6184061972 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6184161973 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6184261974 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61845,12 +61977,12 @@
6184561977 state.addr = 819847183515949359LLU; // reportinit
6184661978 break;
6184761979 }
61848- case 18446744073709547981LLU: // 99999999GM'''''''''''''''
61980+ case 18446744073709547965LLU: // 99999999F7'''''''''''''''
6184961981 {
61850- state.addr = 18446744073709547982LLU; // 99999999GN'''''''''''''''
61982+ state.addr = 18446744073709547966LLU; // 99999999F8'''''''''''''''
6185161983 break;
6185261984 }
61853- case 18446744073709547982LLU: // 99999999GN'''''''''''''''
61985+ case 18446744073709547966LLU: // 99999999F8'''''''''''''''
6185461986 {
6185561987 printid(stderr, /*srcid_____*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU));
6185661988 fprintf(stderr, "%s", " / ");
@@ -61862,10 +61994,10 @@
6186261994 }
6186361995 heap.availilable_size_for_dynamic_objects += 0LLU;
6186461996 heap.availilable_size_for_dynamic_objects += 0LLU;
61865- state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
61997+ state.addr = 18446744073709547964LLU; // 99999999F6'''''''''''''''
6186661998 break;
6186761999 }
61868- case 18446744073709547983LLU: // 99999999GO'''''''''''''''
62000+ case 18446744073709547967LLU: // 99999999F9'''''''''''''''
6186962001 {
6187062002 // ACCUMULATE ARGUMENTS - BEGIN
6187162003 {
@@ -61877,7 +62009,7 @@
6187762009 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6187862010 }
6187962011 // ACCUMULATE ARGUMENTS - END
61880- uint64_t return_to = 18446744073709547978LLU;
62012+ uint64_t return_to = 18446744073709547962LLU;
6188162013 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6188262014 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6188362015 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61886,12 +62018,12 @@
6188662018 state.addr = 517555565476695680LLU; // assertu64_
6188762019 break;
6188862020 }
61889- case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
62021+ case 18446744073709547962LLU: // 99999999F4'''''''''''''''
6189062022 {
61891- state.addr = 18446744073709547979LLU; // 99999999GK'''''''''''''''
62023+ state.addr = 18446744073709547963LLU; // 99999999F5'''''''''''''''
6189262024 break;
6189362025 }
61894- case 18446744073709547979LLU: // 99999999GK'''''''''''''''
62026+ case 18446744073709547963LLU: // 99999999F5'''''''''''''''
6189562027 {
6189662028 // ACCUMULATE ARGUMENTS - BEGIN
6189762029 {
@@ -61915,7 +62047,7 @@
6191562047 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6191662048 }
6191762049 // ACCUMULATE ARGUMENTS - END
61918- uint64_t return_to = 18446744073709547976LLU;
62050+ uint64_t return_to = 18446744073709547960LLU;
6191962051 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6192062052 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6192162053 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61924,12 +62056,12 @@
6192462056 state.addr = 587881357514113024LLU; // emitpar___
6192562057 break;
6192662058 }
61927- case 18446744073709547976LLU: // 99999999GH'''''''''''''''
62059+ case 18446744073709547960LLU: // 99999999F2'''''''''''''''
6192862060 {
61929- state.addr = 18446744073709547977LLU; // 99999999GI'''''''''''''''
62061+ state.addr = 18446744073709547961LLU; // 99999999F3'''''''''''''''
6193062062 break;
6193162063 }
61932- case 18446744073709547977LLU: // 99999999GI'''''''''''''''
62064+ case 18446744073709547961LLU: // 99999999F3'''''''''''''''
6193362065 {
6193462066 fprintf(stdout, "%s", " = ");
6193562067 *LOCAL_ACCESS(heap.data, 22LLU, 14LLU) = 0LLU;
@@ -61944,7 +62076,7 @@
6194462076 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6194562077 }
6194662078 // ACCUMULATE ARGUMENTS - END
61947- uint64_t return_to = 18446744073709547974LLU;
62079+ uint64_t return_to = 18446744073709547958LLU;
6194862080 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6194962081 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6195062082 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -61953,12 +62085,12 @@
6195362085 state.addr = 861504796319285248LLU; // typeu64___
6195462086 break;
6195562087 }
61956- case 18446744073709547974LLU: // 99999999GF'''''''''''''''
62088+ case 18446744073709547958LLU: // 99999999F0'''''''''''''''
6195762089 {
61958- state.addr = 18446744073709547975LLU; // 99999999GG'''''''''''''''
62090+ state.addr = 18446744073709547959LLU; // 99999999F1'''''''''''''''
6195962091 break;
6196062092 }
61961- case 18446744073709547975LLU: // 99999999GG'''''''''''''''
62093+ case 18446744073709547959LLU: // 99999999F1'''''''''''''''
6196262094 {
6196362095 {
6196462096 uint64_t arg = 0;
@@ -62034,7 +62166,7 @@
6203462166 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6203562167 }
6203662168 // ACCUMULATE ARGUMENTS - END
62037- uint64_t return_to = 18446744073709547972LLU;
62169+ uint64_t return_to = 18446744073709547956LLU;
6203862170 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6203962171 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6204062172 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62043,12 +62175,12 @@
6204362175 state.addr = 787472342492567585LLU; // procvarref
6204462176 break;
6204562177 }
62046- case 18446744073709547972LLU: // 99999999GD'''''''''''''''
62178+ case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
6204762179 {
62048- state.addr = 18446744073709547973LLU; // 99999999GE'''''''''''''''
62180+ state.addr = 18446744073709547957LLU; // 99999999Fz'''''''''''''''
6204962181 break;
6205062182 }
62051- case 18446744073709547973LLU: // 99999999GE'''''''''''''''
62183+ case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
6205262184 {
6205362185 // ACCUMULATE ARGUMENTS - BEGIN
6205462186 {
@@ -62068,7 +62200,7 @@
6206862200 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6206962201 }
6207062202 // ACCUMULATE ARGUMENTS - END
62071- uint64_t return_to = 18446744073709547970LLU;
62203+ uint64_t return_to = 18446744073709547954LLU;
6207262204 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6207362205 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6207462206 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62077,12 +62209,12 @@
6207762209 state.addr = 861504774606571689LLU; // typeassign
6207862210 break;
6207962211 }
62080- case 18446744073709547970LLU: // 99999999GB'''''''''''''''
62212+ case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
6208162213 {
62082- state.addr = 18446744073709547971LLU; // 99999999GC'''''''''''''''
62214+ state.addr = 18446744073709547955LLU; // 99999999Fx'''''''''''''''
6208362215 break;
6208462216 }
62085- case 18446744073709547971LLU: // 99999999GC'''''''''''''''
62217+ case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
6208662218 {
6208762219 // variable u64 parameter_ goes out of scope
6208862220 // emitted destructur for type u64
@@ -62098,7 +62230,7 @@
6209862230 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6209962231 }
6210062232 // ACCUMULATE ARGUMENTS - END
62101- uint64_t return_to = 18446744073709547969LLU;
62233+ uint64_t return_to = 18446744073709547953LLU;
6210262234 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6210362235 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6210462236 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62107,13 +62239,13 @@
6210762239 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6210862240 break;
6210962241 }
62110- case 18446744073709547969LLU: // 99999999GA'''''''''''''''
62242+ case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
6211162243 {
6211262244 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 23
62113- state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
62245+ state.addr = 18446744073709547964LLU; // 99999999F6'''''''''''''''
6211462246 break;
6211562247 }
62116- case 18446744073709547980LLU: // 99999999GL'''''''''''''''
62248+ case 18446744073709547964LLU: // 99999999F6'''''''''''''''
6211762249 {
6211862250 // variable u64 called____ goes out of scope
6211962251 // emitted destructur for type u64
@@ -62124,21 +62256,21 @@
6212462256 // variable u64 srcid_____ goes out of scope
6212562257 // emitted destructur for type u64
6212662258 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcid_____ at 20
62127- state.addr = 18446744073709547989LLU; // 99999999GU'''''''''''''''
62259+ state.addr = 18446744073709547973LLU; // 99999999GE'''''''''''''''
6212862260 break;
6212962261 }
62130- case 18446744073709547989LLU: // 99999999GU'''''''''''''''
62262+ case 18446744073709547973LLU: // 99999999GE'''''''''''''''
6213162263 {
6213262264 fprintf(stdout, "%s", ";\n");
62133- state.addr = 18446744073709547994LLU; // 99999999GZ'''''''''''''''
62265+ state.addr = 18446744073709547978LLU; // 99999999GJ'''''''''''''''
6213462266 break;
6213562267 }
62136- case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
62268+ case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
6213762269 {
62138- state.addr = 18446744073709548015LLU; // 99999999Gt'''''''''''''''
62270+ state.addr = 18446744073709547999LLU; // 99999999Gd'''''''''''''''
6213962271 break;
6214062272 }
62141- case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
62273+ case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
6214262274 {
6214362275 // variable u64 match_____ goes out of scope
6214462276 // emitted destructur for type u64
@@ -62163,7 +62295,7 @@
6216362295 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6216462296 }
6216562297 // ACCUMULATE ARGUMENTS - END
62166- uint64_t return_to = 18446744073709547968LLU;
62298+ uint64_t return_to = 18446744073709547952LLU;
6216762299 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6216862300 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6216962301 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62172,7 +62304,7 @@
6217262304 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6217362305 break;
6217462306 }
62175- case 18446744073709547968LLU: // 99999999G_'''''''''''''''
62307+ case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
6217662308 {
6217762309 (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPEDST___ at 14
6217862310 // parameter-reference u64 remainheap goes out of scope
@@ -62241,7 +62373,7 @@
6224162373 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6224262374 }
6224362375 // ACCUMULATE ARGUMENTS - END
62244- uint64_t return_to = 18446744073709547966LLU;
62376+ uint64_t return_to = 18446744073709547950LLU;
6224562377 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
6224662378 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6224762379 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62250,12 +62382,12 @@
6225062382 state.addr = 533581901922699840LLU; // blockopen_
6225162383 break;
6225262384 }
62253- case 18446744073709547966LLU: // 99999999F8'''''''''''''''
62385+ case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
6225462386 {
62255- state.addr = 18446744073709547967LLU; // 99999999F9'''''''''''''''
62387+ state.addr = 18446744073709547951LLU; // 99999999Ft'''''''''''''''
6225662388 break;
6225762389 }
62258- case 18446744073709547967LLU: // 99999999F9'''''''''''''''
62390+ case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
6225962391 {
6226062392 {
6226162393 uint64_t arg = 0;
@@ -62267,7 +62399,7 @@
6226762399 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6226862400 }
6226962401 // ACCUMULATE ARGUMENTS - END
62270- uint64_t return_to = 18446744073709547964LLU;
62402+ uint64_t return_to = 18446744073709547948LLU;
6227162403 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6227262404 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6227362405 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62276,12 +62408,12 @@
6227662408 state.addr = 839519719621918720LLU; // skipws____
6227762409 break;
6227862410 }
62279- case 18446744073709547964LLU: // 99999999F6'''''''''''''''
62411+ case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
6228062412 {
62281- state.addr = 18446744073709547965LLU; // 99999999F7'''''''''''''''
62413+ state.addr = 18446744073709547949LLU; // 99999999Fr'''''''''''''''
6228262414 break;
6228362415 }
62284- case 18446744073709547965LLU: // 99999999F7'''''''''''''''
62416+ case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
6228562417 {
6228662418 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)), stdin);
6228762419 if('(' != (char)getchar())
@@ -62289,15 +62421,15 @@
6228962421 fprintf(stderr, "match failed at char %c\n", (char)40LLU);
6229062422 exit(-1);
6229162423 }
62292- state.addr = 18446744073709547963LLU; // 99999999F5'''''''''''''''
62424+ state.addr = 18446744073709547947LLU; // 99999999Fp'''''''''''''''
6229362425 break;
6229462426 }
62295- case 18446744073709547963LLU: // 99999999F5'''''''''''''''
62427+ case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
6229662428 {
6229762429 *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
6229862430 if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255)
6229962431 {
62300- state.addr = 18446744073709547962LLU; // 99999999F4'''''''''''''''
62432+ state.addr = 18446744073709547946LLU; // 99999999Fo'''''''''''''''
6230162433 break;
6230262434 }
6230362435 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62306,7 +62438,7 @@
6230662438 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6230762439 }
6230862440 // ACCUMULATE ARGUMENTS - END
62309- uint64_t return_to = 18446744073709547960LLU;
62441+ uint64_t return_to = 18446744073709547944LLU;
6231062442 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6231162443 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6231262444 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62315,12 +62447,12 @@
6231562447 state.addr = 839519719621918720LLU; // skipws____
6231662448 break;
6231762449 }
62318- case 18446744073709547960LLU: // 99999999F2'''''''''''''''
62450+ case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
6231962451 {
62320- state.addr = 18446744073709547961LLU; // 99999999F3'''''''''''''''
62452+ state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
6232162453 break;
6232262454 }
62323- case 18446744073709547961LLU: // 99999999F3'''''''''''''''
62455+ case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
6232462456 {
6232562457 {
6232662458 uint64_t arg = 0;
@@ -62338,10 +62470,10 @@
6233862470 }
6233962471 *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 0;
6234062472 /*result____*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
62341- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547959LLU : 18446744073709547958LLU;
62473+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547943LLU : 18446744073709547942LLU;
6234262474 break;
6234362475 }
62344- case 18446744073709547959LLU: // 99999999F1'''''''''''''''
62476+ case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
6234562477 {
6234662478 {
6234762479 uint64_t arg = 0;
@@ -62354,7 +62486,7 @@
6235462486 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6235562487 }
6235662488 // ACCUMULATE ARGUMENTS - END
62357- uint64_t return_to = 18446744073709547956LLU;
62489+ uint64_t return_to = 18446744073709547940LLU;
6235862490 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6235962491 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6236062492 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62363,12 +62495,12 @@
6236362495 state.addr = 839519719621918720LLU; // skipws____
6236462496 break;
6236562497 }
62366- case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
62498+ case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
6236762499 {
62368- state.addr = 18446744073709547957LLU; // 99999999Fz'''''''''''''''
62500+ state.addr = 18446744073709547941LLU; // 99999999Fj'''''''''''''''
6236962501 break;
6237062502 }
62371- case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
62503+ case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
6237262504 {
6237362505 /*resultid__*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
6237462506 {
@@ -62381,7 +62513,7 @@
6238162513 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6238262514 }
6238362515 // ACCUMULATE ARGUMENTS - END
62384- uint64_t return_to = 18446744073709547953LLU;
62516+ uint64_t return_to = 18446744073709547937LLU;
6238562517 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6238662518 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6238762519 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62390,12 +62522,12 @@
6239062522 state.addr = 861504796319285248LLU; // typeu64___
6239162523 break;
6239262524 }
62393- case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
62525+ case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
6239462526 {
62395- state.addr = 18446744073709547954LLU; // 99999999Fw'''''''''''''''
62527+ state.addr = 18446744073709547938LLU; // 99999999Fg'''''''''''''''
6239662528 break;
6239762529 }
62398- case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
62530+ case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
6239962531 {
6240062532 {
6240162533 uint64_t arg = 0;
@@ -62482,7 +62614,7 @@
6248262614 LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6248362615 }
6248462616 // ACCUMULATE ARGUMENTS - END
62485- uint64_t return_to = 18446744073709547951LLU;
62617+ uint64_t return_to = 18446744073709547935LLU;
6248662618 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0));
6248762619 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6248862620 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62491,27 +62623,27 @@
6249162623 state.addr = 604790753280317473LLU; // findvarref
6249262624 break;
6249362625 }
62494- case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
62626+ case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
6249562627 {
62496- state.addr = 18446744073709547952LLU; // 99999999Fu'''''''''''''''
62628+ state.addr = 18446744073709547936LLU; // 99999999Fe'''''''''''''''
6249762629 break;
6249862630 }
62499- case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
62631+ case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
6250062632 {
62501- state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547950LLU : 18446744073709547949LLU;
62633+ state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547934LLU : 18446744073709547933LLU;
6250262634 break;
6250362635 }
62504- case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
62636+ case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
6250562637 {
62506- state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709547948LLU : 18446744073709547947LLU;
62638+ state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709547932LLU : 18446744073709547931LLU;
6250762639 break;
6250862640 }
62509- case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
62641+ case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
6251062642 {
62511- state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 30LLU, 22LLU)].elem0 ? 18446744073709547946LLU : 18446744073709547945LLU;
62643+ state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 30LLU, 22LLU)].elem0 ? 18446744073709547930LLU : 18446744073709547929LLU;
6251262644 break;
6251362645 }
62514- case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
62646+ case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
6251562647 {
6251662648 {
6251762649 uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/*addr-content-pair*/, LOCAL_ACCESS_ADDR(heap.data, 30LLU, 22LLU), 1/*content*/), 0LLU);
@@ -62536,7 +62668,7 @@
6253662668 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6253762669 }
6253862670 // ACCUMULATE ARGUMENTS - END
62539- uint64_t return_to = 18446744073709547943LLU;
62671+ uint64_t return_to = 18446744073709547927LLU;
6254062672 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6254162673 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6254262674 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62545,12 +62677,12 @@
6254562677 state.addr = 861504788261634048LLU; // typename__
6254662678 break;
6254762679 }
62548- case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
62680+ case 18446744073709547927LLU: // 99999999FW'''''''''''''''
6254962681 {
62550- state.addr = 18446744073709547944LLU; // 99999999Fm'''''''''''''''
62682+ state.addr = 18446744073709547928LLU; // 99999999FX'''''''''''''''
6255162683 break;
6255262684 }
62553- case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
62685+ case 18446744073709547928LLU: // 99999999FX'''''''''''''''
6255462686 {
6255562687 // ACCUMULATE ARGUMENTS - BEGIN
6255662688 {
@@ -62590,7 +62722,7 @@
6259062722 LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6259162723 }
6259262724 // ACCUMULATE ARGUMENTS - END
62593- uint64_t return_to = 18446744073709547941LLU;
62725+ uint64_t return_to = 18446744073709547925LLU;
6259462726 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0));
6259562727 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6259662728 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62599,12 +62731,12 @@
6259962731 state.addr = 587881344696777536LLU; // emitdestr_
6260062732 break;
6260162733 }
62602- case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
62734+ case 18446744073709547925LLU: // 99999999FU'''''''''''''''
6260362735 {
62604- state.addr = 18446744073709547942LLU; // 99999999Fk'''''''''''''''
62736+ state.addr = 18446744073709547926LLU; // 99999999FV'''''''''''''''
6260562737 break;
6260662738 }
62607- case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
62739+ case 18446744073709547926LLU: // 99999999FV'''''''''''''''
6260862740 {
6260962741 // variable type______ type______ goes out of scope
6261062742 // emitted destructur for type type______
@@ -62614,7 +62746,7 @@
6261462746 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6261562747 }
6261662748 // ACCUMULATE ARGUMENTS - END
62617- uint64_t return_to = 18446744073709547940LLU;
62749+ uint64_t return_to = 18446744073709547924LLU;
6261862750 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6261962751 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6262062752 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62623,7 +62755,7 @@
6262362755 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6262462756 break;
6262562757 }
62626- case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
62758+ case 18446744073709547924LLU: // 99999999FT'''''''''''''''
6262762759 {
6262862760 (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 33
6262962761 // variable u64 name______ goes out of scope
@@ -62633,22 +62765,22 @@
6263362765 (void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 31
6263462766 heap.availilable_size_for_dynamic_objects += 0LLU;
6263562767 heap.availilable_size_for_dynamic_objects += 0LLU;
62636- state.addr = 18446744073709547939LLU; // 99999999Fh'''''''''''''''
62768+ state.addr = 18446744073709547923LLU; // 99999999FS'''''''''''''''
6263762769 break;
6263862770 }
62639- case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
62771+ case 18446744073709547929LLU: // 99999999FY'''''''''''''''
6264062772 {
62641- state.addr = 18446744073709547939LLU; // 99999999Fh'''''''''''''''
62773+ state.addr = 18446744073709547923LLU; // 99999999FS'''''''''''''''
6264262774 break;
6264362775 }
62644- case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
62776+ case 18446744073709547923LLU: // 99999999FS'''''''''''''''
6264562777 {
6264662778 heap.availilable_size_for_dynamic_objects += 0LLU;
6264762779 heap.availilable_size_for_dynamic_objects += 0LLU;
62648- state.addr = 18446744073709547938LLU; // 99999999Fg'''''''''''''''
62780+ state.addr = 18446744073709547922LLU; // 99999999FR'''''''''''''''
6264962781 break;
6265062782 }
62651- case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
62783+ case 18446744073709547931LLU: // 99999999F$'''''''''''''''
6265262784 {
6265362785 fprintf(stderr, "%s", "cannot assign to constant ");
6265462786 // ACCUMULATE ARGUMENTS - BEGIN
@@ -62657,7 +62789,7 @@
6265762789 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6265862790 }
6265962791 // ACCUMULATE ARGUMENTS - END
62660- uint64_t return_to = 18446744073709547936LLU;
62792+ uint64_t return_to = 18446744073709547920LLU;
6266162793 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6266262794 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6266362795 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62666,12 +62798,12 @@
6266662798 state.addr = 819847183518878432LLU; // reporttype
6266762799 break;
6266862800 }
62669- case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
62801+ case 18446744073709547920LLU: // 99999999FP'''''''''''''''
6267062802 {
62671- state.addr = 18446744073709547937LLU; // 99999999Ff'''''''''''''''
62803+ state.addr = 18446744073709547921LLU; // 99999999FQ'''''''''''''''
6267262804 break;
6267362805 }
62674- case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
62806+ case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
6267562807 {
6267662808 fprintf(stderr, "%s", " ");
6267762809 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 30LLU, 21LLU));
@@ -62679,17 +62811,17 @@
6267962811 fprintf(stderr, "%s\n", "");
6268062812 exit(-1);
6268162813 }
62682- state.addr = 18446744073709547938LLU; // 99999999Fg'''''''''''''''
62814+ state.addr = 18446744073709547922LLU; // 99999999FR'''''''''''''''
6268362815 break;
6268462816 }
62685- case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
62817+ case 18446744073709547922LLU: // 99999999FR'''''''''''''''
6268662818 {
6268762819 heap.availilable_size_for_dynamic_objects += 0LLU;
6268862820 heap.availilable_size_for_dynamic_objects += 0LLU;
62689- state.addr = 18446744073709547935LLU; // 99999999Fd'''''''''''''''
62821+ state.addr = 18446744073709547919LLU; // 99999999FO'''''''''''''''
6269062822 break;
6269162823 }
62692- case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
62824+ case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
6269362825 {
6269462826 // ACCUMULATE ARGUMENTS - BEGIN
6269562827 {
@@ -62709,7 +62841,7 @@
6270962841 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6271062842 }
6271162843 // ACCUMULATE ARGUMENTS - END
62712- uint64_t return_to = 18446744073709547933LLU;
62844+ uint64_t return_to = 18446744073709547917LLU;
6271362845 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6271462846 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6271562847 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62718,17 +62850,17 @@
6271862850 state.addr = 660220432971388961LLU; // initvarref
6271962851 break;
6272062852 }
62721- case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
62853+ case 18446744073709547917LLU: // 99999999FM'''''''''''''''
6272262854 {
62723- state.addr = 18446744073709547934LLU; // 99999999Fc'''''''''''''''
62855+ state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
6272462856 break;
6272562857 }
62726- case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
62858+ case 18446744073709547918LLU: // 99999999FN'''''''''''''''
6272762859 {
62728- state.addr = 18446744073709547935LLU; // 99999999Fd'''''''''''''''
62860+ state.addr = 18446744073709547919LLU; // 99999999FO'''''''''''''''
6272962861 break;
6273062862 }
62731- case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
62863+ case 18446744073709547919LLU: // 99999999FO'''''''''''''''
6273262864 {
6273362865 {
6273462866 uint64_t arg = 0;
@@ -62763,7 +62895,7 @@
6276362895 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6276462896 }
6276562897 // ACCUMULATE ARGUMENTS - END
62766- uint64_t return_to = 18446744073709547931LLU;
62898+ uint64_t return_to = 18446744073709547915LLU;
6276762899 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6276862900 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6276962901 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62772,12 +62904,12 @@
6277262904 state.addr = 734295421765213120LLU; // mutassert_
6277362905 break;
6277462906 }
62775- case 18446744073709547931LLU: // 99999999F$'''''''''''''''
62907+ case 18446744073709547915LLU: // 99999999FK'''''''''''''''
6277662908 {
62777- state.addr = 18446744073709547932LLU; // 99999999Fa'''''''''''''''
62909+ state.addr = 18446744073709547916LLU; // 99999999FL'''''''''''''''
6277862910 break;
6277962911 }
62780- case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
62912+ case 18446744073709547916LLU: // 99999999FL'''''''''''''''
6278162913 {
6278262914 {
6278362915 uint64_t arg = 0;
@@ -62807,7 +62939,7 @@
6280762939 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6280862940 }
6280962941 // ACCUMULATE ARGUMENTS - END
62810- uint64_t return_to = 18446744073709547924LLU;
62942+ uint64_t return_to = 18446744073709547908LLU;
6281162943 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6281262944 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6281362945 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62816,12 +62948,12 @@
6281662948 state.addr = 890786773858934784LLU; // varblock__
6281762949 break;
6281862950 }
62819- case 18446744073709547924LLU: // 99999999FT'''''''''''''''
62951+ case 18446744073709547908LLU: // 99999999FD'''''''''''''''
6282062952 {
62821- state.addr = 18446744073709547925LLU; // 99999999FU'''''''''''''''
62953+ state.addr = 18446744073709547909LLU; // 99999999FE'''''''''''''''
6282262954 break;
6282362955 }
62824- case 18446744073709547925LLU: // 99999999FU'''''''''''''''
62956+ case 18446744073709547909LLU: // 99999999FE'''''''''''''''
6282562957 {
6282662958 {
6282762959 uint64_t exchange = LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 36*/;
@@ -62837,7 +62969,7 @@
6283762969 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6283862970 }
6283962971 // ACCUMULATE ARGUMENTS - END
62840- uint64_t return_to = 18446744073709547926LLU;
62972+ uint64_t return_to = 18446744073709547910LLU;
6284162973 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6284262974 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6284362975 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62846,17 +62978,17 @@
6284662978 state.addr = 890786982252724224LLU; // varentry__
6284762979 break;
6284862980 }
62849- case 18446744073709547926LLU: // 99999999FV'''''''''''''''
62981+ case 18446744073709547910LLU: // 99999999FF'''''''''''''''
6285062982 {
62851- state.addr = 18446744073709547927LLU; // 99999999FW'''''''''''''''
62983+ state.addr = 18446744073709547911LLU; // 99999999FG'''''''''''''''
6285262984 break;
6285362985 }
62854- case 18446744073709547927LLU: // 99999999FW'''''''''''''''
62986+ case 18446744073709547911LLU: // 99999999FG'''''''''''''''
6285562987 {
62856- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547929LLU : 18446744073709547928LLU;
62988+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547913LLU : 18446744073709547912LLU;
6285762989 break;
6285862990 }
62859- case 18446744073709547929LLU: // 99999999FY'''''''''''''''
62991+ case 18446744073709547913LLU: // 99999999FI'''''''''''''''
6286062992 {
6286162993 {
6286262994 uint64_t arg = *LOCAL_ACCESS(heap.data, 34LLU, 33LLU);
@@ -62868,7 +63000,7 @@
6286863000 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6286963001 }
6287063002 // ACCUMULATE ARGUMENTS - END
62871- uint64_t return_to = 18446744073709547922LLU;
63003+ uint64_t return_to = 18446744073709547906LLU;
6287263004 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6287363005 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6287463006 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62877,12 +63009,12 @@
6287763009 state.addr = 819847183515949359LLU; // reportinit
6287863010 break;
6287963011 }
62880- case 18446744073709547922LLU: // 99999999FR'''''''''''''''
63012+ case 18446744073709547906LLU: // 99999999FB'''''''''''''''
6288163013 {
62882- state.addr = 18446744073709547923LLU; // 99999999FS'''''''''''''''
63014+ state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
6288363015 break;
6288463016 }
62885- case 18446744073709547923LLU: // 99999999FS'''''''''''''''
63017+ case 18446744073709547907LLU: // 99999999FC'''''''''''''''
6288663018 {
6288763019 fprintf(stderr, "%s", "pushing block ");
6288863020 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 35LLU, 21LLU));
@@ -62899,7 +63031,7 @@
6289963031 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6290063032 }
6290163033 // ACCUMULATE ARGUMENTS - END
62902- uint64_t return_to = 18446744073709547921LLU;
63034+ uint64_t return_to = 18446744073709547905LLU;
6290363035 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6290463036 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6290563037 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62908,20 +63040,20 @@
6290863040 state.addr = 18446744073709551039LLU; // 9999999909'''''''''''''''
6290963041 break;
6291063042 }
62911- case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
63043+ case 18446744073709547905LLU: // 99999999FA'''''''''''''''
6291263044 {
6291363045 (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference block_____ at 35
6291463046 heap.availilable_size_for_dynamic_objects += 0LLU;
6291563047 heap.availilable_size_for_dynamic_objects += 0LLU;
62916- state.addr = 18446744073709547920LLU; // 99999999FP'''''''''''''''
63048+ state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
6291763049 break;
6291863050 }
62919- case 18446744073709547928LLU: // 99999999FX'''''''''''''''
63051+ case 18446744073709547912LLU: // 99999999FH'''''''''''''''
6292063052 {
62921- state.addr = 18446744073709547920LLU; // 99999999FP'''''''''''''''
63053+ state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
6292263054 break;
6292363055 }
62924- case 18446744073709547920LLU: // 99999999FP'''''''''''''''
63056+ case 18446744073709547904LLU: // 99999999F_'''''''''''''''
6292563057 {
6292663058 // variable varentry__ __________ goes out of scope
6292763059 // (uninitialized -> no destructor-call)
@@ -62929,10 +63061,10 @@
6292963061 // variable u64 id2_______ goes out of scope
6293063062 // (uninitialized -> no destructor-call)
6293163063 (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id2_______ at 33
62932- state.addr = 18446744073709547930LLU; // 99999999FZ'''''''''''''''
63064+ state.addr = 18446744073709547914LLU; // 99999999FJ'''''''''''''''
6293363065 break;
6293463066 }
62935- case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
63067+ case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
6293663068 {/*resdest___*/
6293763069 {
6293863070 uint64_t arg = 0;
@@ -62956,7 +63088,7 @@
6295663088 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6295763089 }
6295863090 // ACCUMULATE ARGUMENTS - END
62959- uint64_t return_to = 18446744073709547915LLU;
63091+ uint64_t return_to = 18446744073709547899LLU;
6296063092 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6296163093 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6296263094 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62965,17 +63097,17 @@
6296563097 state.addr = 819859607768530944LLU; // resdest___
6296663098 break;
6296763099 }
62968- case 18446744073709547915LLU: // 99999999FK'''''''''''''''
63100+ case 18446744073709547899LLU: // 99999999E5'''''''''''''''
6296963101 {
62970- state.addr = 18446744073709547916LLU; // 99999999FL'''''''''''''''
63102+ state.addr = 18446744073709547900LLU; // 99999999E6'''''''''''''''
6297163103 break;
6297263104 }
62973- case 18446744073709547916LLU: // 99999999FL'''''''''''''''
63105+ case 18446744073709547900LLU: // 99999999E6'''''''''''''''
6297463106 {
62975- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &*LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547918LLU : 18446744073709547917LLU;
63107+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &*LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547902LLU : 18446744073709547901LLU;
6297663108 break;
6297763109 }
62978- case 18446744073709547918LLU: // 99999999FN'''''''''''''''
63110+ case 18446744073709547902LLU: // 99999999E8'''''''''''''''
6297963111 {
6298063112 {
6298163113 uint64_t arg = *LOCAL_ACCESS(heap.data, 33LLU, 32LLU);
@@ -62987,7 +63119,7 @@
6298763119 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6298863120 }
6298963121 // ACCUMULATE ARGUMENTS - END
62990- uint64_t return_to = 18446744073709547913LLU;
63122+ uint64_t return_to = 18446744073709547897LLU;
6299163123 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6299263124 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6299363125 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -62996,12 +63128,12 @@
6299663128 state.addr = 819847183515949359LLU; // reportinit
6299763129 break;
6299863130 }
62999- case 18446744073709547913LLU: // 99999999FI'''''''''''''''
63131+ case 18446744073709547897LLU: // 99999999E3'''''''''''''''
6300063132 {
63001- state.addr = 18446744073709547914LLU; // 99999999FJ'''''''''''''''
63133+ state.addr = 18446744073709547898LLU; // 99999999E4'''''''''''''''
6300263134 break;
6300363135 }
63004- case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
63136+ case 18446744073709547898LLU: // 99999999E4'''''''''''''''
6300563137 {
6300663138 fprintf(stderr, "%s", "pushing assignment-destination ");
6300763139 printid(stderr, /*resultid__*/*LOCAL_ACCESS(heap.data, 34LLU, 21LLU));
@@ -63018,7 +63150,7 @@
6301863150 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6301963151 }
6302063152 // ACCUMULATE ARGUMENTS - END
63021- uint64_t return_to = 18446744073709547912LLU;
63153+ uint64_t return_to = 18446744073709547896LLU;
6302263154 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6302363155 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6302463156 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63027,28 +63159,28 @@
6302763159 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6302863160 break;
6302963161 }
63030- case 18446744073709547912LLU: // 99999999FH'''''''''''''''
63162+ case 18446744073709547896LLU: // 99999999E2'''''''''''''''
6303163163 {
6303263164 (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference assignto__ at 34
6303363165 heap.availilable_size_for_dynamic_objects += 0LLU;
6303463166 heap.availilable_size_for_dynamic_objects += 0LLU;
63035- state.addr = 18446744073709547911LLU; // 99999999FG'''''''''''''''
63167+ state.addr = 18446744073709547895LLU; // 99999999E1'''''''''''''''
6303663168 break;
6303763169 }
63038- case 18446744073709547917LLU: // 99999999FM'''''''''''''''
63170+ case 18446744073709547901LLU: // 99999999E7'''''''''''''''
6303963171 {
63040- state.addr = 18446744073709547911LLU; // 99999999FG'''''''''''''''
63172+ state.addr = 18446744073709547895LLU; // 99999999E1'''''''''''''''
6304163173 break;
6304263174 }
63043- case 18446744073709547911LLU: // 99999999FG'''''''''''''''
63175+ case 18446744073709547895LLU: // 99999999E1'''''''''''''''
6304463176 {
6304563177 // variable resdest___ __________ goes out of scope
6304663178 // (uninitialized -> no destructor-call)
6304763179 (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 33
63048- state.addr = 18446744073709547919LLU; // 99999999FO'''''''''''''''
63180+ state.addr = 18446744073709547903LLU; // 99999999E9'''''''''''''''
6304963181 break;
6305063182 }
63051- case 18446744073709547919LLU: // 99999999FO'''''''''''''''
63183+ case 18446744073709547903LLU: // 99999999E9'''''''''''''''
6305263184 {
6305363185 // variable u64 callee_id_ goes out of scope
6305463186 // emitted destructur for type u64
@@ -63080,10 +63212,10 @@
6308063212 // variable type______ type______ goes out of scope
6308163213 // (uninitialized -> no destructor-call)
6308263214 (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 23
63083- state.addr = 18446744073709547955LLU; // 99999999Fx'''''''''''''''
63215+ state.addr = 18446744073709547939LLU; // 99999999Fh'''''''''''''''
6308463216 break;
6308563217 }
63086- case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
63218+ case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
6308763219 {
6308863220 // ACCUMULATE ARGUMENTS - BEGIN
6308963221 {
@@ -63091,7 +63223,7 @@
6309163223 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6309263224 }
6309363225 // ACCUMULATE ARGUMENTS - END
63094- uint64_t return_to = 18446744073709547909LLU;
63226+ uint64_t return_to = 18446744073709547893LLU;
6309563227 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6309663228 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6309763229 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63100,32 +63232,32 @@
6310063232 state.addr = 839519719621918720LLU; // skipws____
6310163233 break;
6310263234 }
63103- case 18446744073709547909LLU: // 99999999FE'''''''''''''''
63235+ case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
6310463236 {
63105- state.addr = 18446744073709547910LLU; // 99999999FF'''''''''''''''
63237+ state.addr = 18446744073709547894LLU; // 99999999E0'''''''''''''''
6310663238 break;
6310763239 }
63108- case 18446744073709547910LLU: // 99999999FF'''''''''''''''
63240+ case 18446744073709547894LLU: // 99999999E0'''''''''''''''
6310963241 {
6311063242 /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /*separator_*/*LOCAL_ACCESS(heap.data, 22LLU, 18LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
63111- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547908LLU : 18446744073709547907LLU;
63243+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547892LLU : 18446744073709547891LLU;
6311263244 break;
6311363245 }
63114- case 18446744073709547908LLU: // 99999999FD'''''''''''''''
63246+ case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
6311563247 {
6311663248 /*result____*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
63117- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547906LLU : 18446744073709547905LLU;
63249+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547890LLU : 18446744073709547889LLU;
6311863250 break;
6311963251 }
63120- case 18446744073709547906LLU: // 99999999FB'''''''''''''''
63252+ case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
6312163253 {
6312263254 ungetc(0, stdin);
6312363255 heap.availilable_size_for_dynamic_objects += 0LLU;
6312463256 heap.availilable_size_for_dynamic_objects += 0LLU;
63125- state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
63257+ state.addr = 18446744073709547888LLU; // 99999999Eu'''''''''''''''
6312663258 break;
6312763259 }
63128- case 18446744073709547905LLU: // 99999999FA'''''''''''''''
63260+ case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
6312963261 {
6313063262 // ACCUMULATE ARGUMENTS - BEGIN
6313163263 {
@@ -63133,7 +63265,7 @@
6313363265 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6313463266 }
6313563267 // ACCUMULATE ARGUMENTS - END
63136- uint64_t return_to = 18446744073709547902LLU;
63268+ uint64_t return_to = 18446744073709547886LLU;
6313763269 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6313863270 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6313963271 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63142,12 +63274,12 @@
6314263274 state.addr = 819847183515949359LLU; // reportinit
6314363275 break;
6314463276 }
63145- case 18446744073709547902LLU: // 99999999E8'''''''''''''''
63277+ case 18446744073709547886LLU: // 99999999Es'''''''''''''''
6314663278 {
63147- state.addr = 18446744073709547903LLU; // 99999999E9'''''''''''''''
63279+ state.addr = 18446744073709547887LLU; // 99999999Et'''''''''''''''
6314863280 break;
6314963281 }
63150- case 18446744073709547903LLU: // 99999999E9'''''''''''''''
63282+ case 18446744073709547887LLU: // 99999999Et'''''''''''''''
6315163283 {
6315263284 fprintf(stderr, "%s", "expected ',' or ')' but found ");
6315363285 putc((char)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stderr);
@@ -63155,15 +63287,15 @@
6315563287 fprintf(stderr, "%s\n", "");
6315663288 exit(-1);
6315763289 }
63158- state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
63290+ state.addr = 18446744073709547888LLU; // 99999999Eu'''''''''''''''
6315963291 break;
6316063292 }
63161- case 18446744073709547904LLU: // 99999999F_'''''''''''''''
63293+ case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
6316263294 {
63163- state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
63295+ state.addr = 18446744073709547891LLU; // 99999999Ex'''''''''''''''
6316463296 break;
6316563297 }
63166- case 18446744073709547907LLU: // 99999999FC'''''''''''''''
63298+ case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
6316763299 {
6316863300 // variable u64 resultid__ goes out of scope
6316963301 // emitted destructur for type u64
@@ -63170,16 +63302,16 @@
6317063302 (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultid__ at 22
6317163303 heap.availilable_size_for_dynamic_objects += 0LLU;
6317263304 heap.availilable_size_for_dynamic_objects += 0LLU;
63173- state.addr = 18446744073709547901LLU; // 99999999E7'''''''''''''''
63305+ state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
6317463306 break;
6317563307 }
63176- case 18446744073709547958LLU: // 99999999F0'''''''''''''''
63308+ case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
6317763309 {
6317863310 ungetc(0, stdin);
63179- state.addr = 18446744073709547901LLU; // 99999999E7'''''''''''''''
63311+ state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
6318063312 break;
6318163313 }
63182- case 18446744073709547901LLU: // 99999999E7'''''''''''''''
63314+ case 18446744073709547885LLU: // 99999999Er'''''''''''''''
6318363315 {
6318463316 // variable u64 result____ goes out of scope
6318563317 // emitted destructur for type u64
@@ -63190,10 +63322,10 @@
6319063322 // variable u64 separator_ goes out of scope
6319163323 // emitted destructur for type u64
6319263324 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference separator_ at 19
63193- state.addr = 18446744073709547963LLU; // 99999999F5'''''''''''''''
63325+ state.addr = 18446744073709547947LLU; // 99999999Fp'''''''''''''''
6319463326 break;
6319563327 }
63196- case 18446744073709547962LLU: // 99999999F4'''''''''''''''
63328+ case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
6319763329 {
6319863330 /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
6319963331 list_reverse(heap.data, &/*newresults*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU));
@@ -63258,7 +63390,7 @@
6325863390 LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6325963391 }
6326063392 // ACCUMULATE ARGUMENTS - END
63261- uint64_t return_to = 18446744073709547898LLU;
63393+ uint64_t return_to = 18446744073709547882LLU;
6326263394 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0));
6326363395 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6326463396 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63267,17 +63399,17 @@
6326763399 state.addr = 533581901720365984LLU; // blockclose
6326863400 break;
6326963401 }
63270- case 18446744073709547898LLU: // 99999999E4'''''''''''''''
63402+ case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
6327163403 {
63272- state.addr = 18446744073709547899LLU; // 99999999E5'''''''''''''''
63404+ state.addr = 18446744073709547883LLU; // 99999999Ep'''''''''''''''
6327363405 break;
6327463406 }
63275- case 18446744073709547899LLU: // 99999999E5'''''''''''''''
63407+ case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
6327663408 {
63277- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547897LLU : 18446744073709547896LLU;
63409+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547881LLU : 18446744073709547880LLU;
6327863410 break;
6327963411 }
63280- case 18446744073709547897LLU: // 99999999E3'''''''''''''''
63412+ case 18446744073709547881LLU: // 99999999En'''''''''''''''
6328163413 {
6328263414 fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
6328363415 {
@@ -63284,10 +63416,10 @@
6328463416 fprintf(stderr, "%s\n", "");
6328563417 exit(-1);
6328663418 }
63287- state.addr = 18446744073709547896LLU; // 99999999E2'''''''''''''''
63419+ state.addr = 18446744073709547880LLU; // 99999999Em'''''''''''''''
6328863420 break;
6328963421 }
63290- case 18446744073709547896LLU: // 99999999E2'''''''''''''''
63422+ case 18446744073709547880LLU: // 99999999Em'''''''''''''''
6329163423 {
6329263424 {
6329363425 uint64_t arg = 0;
@@ -63295,10 +63427,10 @@
6329563427 }
6329663428 *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 0;
6329763429 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) != /*ds________*/*LOCAL_ACCESS(heap.data, 22LLU, 18LLU);
63298- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547895LLU : 18446744073709547894LLU;
63430+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547879LLU : 18446744073709547878LLU;
6329963431 break;
6330063432 }
63301- case 18446744073709547895LLU: // 99999999E1'''''''''''''''
63433+ case 18446744073709547879LLU: // 99999999El'''''''''''''''
6330263434 {
6330363435 fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
6330463436 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63307,7 +63439,7 @@
6330763439 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6330863440 }
6330963441 // ACCUMULATE ARGUMENTS - END
63310- uint64_t return_to = 18446744073709547892LLU;
63442+ uint64_t return_to = 18446744073709547876LLU;
6331163443 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6331263444 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6331363445 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63316,12 +63448,12 @@
6331663448 state.addr = 819847183517274112LLU; // reportnr__
6331763449 break;
6331863450 }
63319- case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
63451+ case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
6332063452 {
63321- state.addr = 18446744073709547893LLU; // 99999999Ez'''''''''''''''
63453+ state.addr = 18446744073709547877LLU; // 99999999Ej'''''''''''''''
6332263454 break;
6332363455 }
63324- case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
63456+ case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
6332563457 {
6332663458 fprintf(stderr, "%s", " != ");
6332763459 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63330,7 +63462,7 @@
6333063462 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6333163463 }
6333263464 // ACCUMULATE ARGUMENTS - END
63333- uint64_t return_to = 18446744073709547890LLU;
63465+ uint64_t return_to = 18446744073709547874LLU;
6333463466 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6333563467 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6333663468 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63339,27 +63471,27 @@
6333963471 state.addr = 819847183517274112LLU; // reportnr__
6334063472 break;
6334163473 }
63342- case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
63474+ case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
6334363475 {
63344- state.addr = 18446744073709547891LLU; // 99999999Ex'''''''''''''''
63476+ state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
6334563477 break;
6334663478 }
63347- case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
63479+ case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
6334863480 {
6334963481 {
6335063482 fprintf(stderr, "%s\n", "");
6335163483 exit(-1);
6335263484 }
63353- state.addr = 18446744073709547894LLU; // 99999999E0'''''''''''''''
63485+ state.addr = 18446744073709547878LLU; // 99999999Ek'''''''''''''''
6335463486 break;
6335563487 }
63356- case 18446744073709547894LLU: // 99999999E0'''''''''''''''
63488+ case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
6335763489 {
6335863490 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainsize*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 14LLU)) != /*rs________*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
63359- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547889LLU : 18446744073709547888LLU;
63491+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547873LLU : 18446744073709547872LLU;
6336063492 break;
6336163493 }
63362- case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
63494+ case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
6336363495 {
6336463496 fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
6336563497 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63368,7 +63500,7 @@
6336863500 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6336963501 }
6337063502 // ACCUMULATE ARGUMENTS - END
63371- uint64_t return_to = 18446744073709547886LLU;
63503+ uint64_t return_to = 18446744073709547870LLU;
6337263504 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6337363505 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6337463506 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63377,12 +63509,12 @@
6337763509 state.addr = 819847183517274112LLU; // reportnr__
6337863510 break;
6337963511 }
63380- case 18446744073709547886LLU: // 99999999Es'''''''''''''''
63512+ case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
6338163513 {
63382- state.addr = 18446744073709547887LLU; // 99999999Et'''''''''''''''
63514+ state.addr = 18446744073709547871LLU; // 99999999Ed'''''''''''''''
6338363515 break;
6338463516 }
63385- case 18446744073709547887LLU: // 99999999Et'''''''''''''''
63517+ case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
6338663518 {
6338763519 fprintf(stderr, "%s", " != ");
6338863520 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63391,7 +63523,7 @@
6339163523 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6339263524 }
6339363525 // ACCUMULATE ARGUMENTS - END
63394- uint64_t return_to = 18446744073709547884LLU;
63526+ uint64_t return_to = 18446744073709547868LLU;
6339563527 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6339663528 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6339763529 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63400,27 +63532,27 @@
6340063532 state.addr = 819847183517274112LLU; // reportnr__
6340163533 break;
6340263534 }
63403- case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
63535+ case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
6340463536 {
63405- state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
63537+ state.addr = 18446744073709547869LLU; // 99999999Eb'''''''''''''''
6340663538 break;
6340763539 }
63408- case 18446744073709547885LLU: // 99999999Er'''''''''''''''
63540+ case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
6340963541 {
6341063542 {
6341163543 fprintf(stderr, "%s\n", "");
6341263544 exit(-1);
6341363545 }
63414- state.addr = 18446744073709547888LLU; // 99999999Eu'''''''''''''''
63546+ state.addr = 18446744073709547872LLU; // 99999999Ee'''''''''''''''
6341563547 break;
6341663548 }
63417- case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
63549+ case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
6341863550 {
6341963551 /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 15LLU)) != /*rh________*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU);
63420- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547883LLU : 18446744073709547882LLU;
63552+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547867LLU : 18446744073709547866LLU;
6342163553 break;
6342263554 }
63423- case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
63555+ case 18446744073709547867LLU: // 99999999E$'''''''''''''''
6342463556 {
6342563557 fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch ");
6342663558 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63429,7 +63561,7 @@
6342963561 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6343063562 }
6343163563 // ACCUMULATE ARGUMENTS - END
63432- uint64_t return_to = 18446744073709547880LLU;
63564+ uint64_t return_to = 18446744073709547864LLU;
6343363565 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6343463566 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6343563567 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63438,12 +63570,12 @@
6343863570 state.addr = 819847183517274112LLU; // reportnr__
6343963571 break;
6344063572 }
63441- case 18446744073709547880LLU: // 99999999Em'''''''''''''''
63573+ case 18446744073709547864LLU: // 99999999EX'''''''''''''''
6344263574 {
63443- state.addr = 18446744073709547881LLU; // 99999999En'''''''''''''''
63575+ state.addr = 18446744073709547865LLU; // 99999999EY'''''''''''''''
6344463576 break;
6344563577 }
63446- case 18446744073709547881LLU: // 99999999En'''''''''''''''
63578+ case 18446744073709547865LLU: // 99999999EY'''''''''''''''
6344763579 {
6344863580 fprintf(stderr, "%s", " != ");
6344963581 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63452,7 +63584,7 @@
6345263584 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6345363585 }
6345463586 // ACCUMULATE ARGUMENTS - END
63455- uint64_t return_to = 18446744073709547878LLU;
63587+ uint64_t return_to = 18446744073709547862LLU;
6345663588 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6345763589 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6345863590 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63461,21 +63593,21 @@
6346163593 state.addr = 819847183517274112LLU; // reportnr__
6346263594 break;
6346363595 }
63464- case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
63596+ case 18446744073709547862LLU: // 99999999EV'''''''''''''''
6346563597 {
63466- state.addr = 18446744073709547879LLU; // 99999999El'''''''''''''''
63598+ state.addr = 18446744073709547863LLU; // 99999999EW'''''''''''''''
6346763599 break;
6346863600 }
63469- case 18446744073709547879LLU: // 99999999El'''''''''''''''
63601+ case 18446744073709547863LLU: // 99999999EW'''''''''''''''
6347063602 {
6347163603 {
6347263604 fprintf(stderr, "%s\n", "");
6347363605 exit(-1);
6347463606 }
63475- state.addr = 18446744073709547882LLU; // 99999999Eo'''''''''''''''
63607+ state.addr = 18446744073709547866LLU; // 99999999EZ'''''''''''''''
6347663608 break;
6347763609 }
63478- case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
63610+ case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
6347963611 {
6348063612 // variable u64 buf_______ goes out of scope
6348163613 // emitted destructur for type u64
@@ -63489,10 +63621,10 @@
6348963621 // variable u64 ds________ goes out of scope
6349063622 // emitted destructur for type u64
6349163623 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ds________ at 19
63492- state.addr = 18446744073709547900LLU; // 99999999E6'''''''''''''''
63624+ state.addr = 18446744073709547884LLU; // 99999999Eq'''''''''''''''
6349363625 break;
6349463626 }
63495- case 18446744073709547900LLU: // 99999999E6'''''''''''''''
63627+ case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
6349663628 {
6349763629 // ACCUMULATE ARGUMENTS - BEGIN
6349863630 {
@@ -63500,7 +63632,7 @@
6350063632 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6350163633 }
6350263634 // ACCUMULATE ARGUMENTS - END
63503- uint64_t return_to = 18446744073709547876LLU;
63635+ uint64_t return_to = 18446744073709547860LLU;
6350463636 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6350563637 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6350663638 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63509,12 +63641,12 @@
6350963641 state.addr = 839519719621918720LLU; // skipws____
6351063642 break;
6351163643 }
63512- case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
63644+ case 18446744073709547860LLU: // 99999999ET'''''''''''''''
6351363645 {
63514- state.addr = 18446744073709547877LLU; // 99999999Ej'''''''''''''''
63646+ state.addr = 18446744073709547861LLU; // 99999999EU'''''''''''''''
6351563647 break;
6351663648 }
63517- case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
63649+ case 18446744073709547861LLU: // 99999999EU'''''''''''''''
6351863650 {
6351963651 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
6352063652 // ACCUMULATE ARGUMENTS - BEGIN
@@ -63523,7 +63655,7 @@
6352363655 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6352463656 }
6352563657 // ACCUMULATE ARGUMENTS - END
63526- uint64_t return_to = 18446744073709547874LLU;
63658+ uint64_t return_to = 18446744073709547858LLU;
6352763659 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6352863660 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6352963661 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63532,12 +63664,12 @@
6353263664 state.addr = 839519719621918720LLU; // skipws____
6353363665 break;
6353463666 }
63535- case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
63667+ case 18446744073709547858LLU: // 99999999ER'''''''''''''''
6353663668 {
63537- state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
63669+ state.addr = 18446744073709547859LLU; // 99999999ES'''''''''''''''
6353863670 break;
6353963671 }
63540- case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
63672+ case 18446744073709547859LLU: // 99999999ES'''''''''''''''
6354163673 {
6354263674 {
6354363675 uint64_t arg = 0;
@@ -63552,10 +63684,10 @@
6355263684 *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 123LLU;
6355363685
6355463686 /*matchsym__*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU));
63555- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) ? 18446744073709547873LLU : 18446744073709547872LLU;
63687+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 18LLU) ? 18446744073709547857LLU : 18446744073709547856LLU;
6355663688 break;
6355763689 }
63558- case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
63690+ case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
6355963691 {
6356063692 // ACCUMULATE ARGUMENTS - BEGIN
6356163693 {
@@ -63583,7 +63715,7 @@
6358363715 LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6358463716 }
6358563717 // ACCUMULATE ARGUMENTS - END
63586- uint64_t return_to = 18446744073709547870LLU;
63718+ uint64_t return_to = 18446744073709547854LLU;
6358763719 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0));
6358863720 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6358963721 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63592,20 +63724,20 @@
6359263724 state.addr = 533581901922699840LLU; // blockopen_
6359363725 break;
6359463726 }
63595- case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
63727+ case 18446744073709547854LLU: // 99999999EN'''''''''''''''
6359663728 {
63597- state.addr = 18446744073709547871LLU; // 99999999Ed'''''''''''''''
63729+ state.addr = 18446744073709547855LLU; // 99999999EO'''''''''''''''
6359863730 break;
6359963731 }
63600- case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
63732+ case 18446744073709547855LLU: // 99999999EO'''''''''''''''
6360163733 {
6360263734 swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU));
6360363735 heap.availilable_size_for_dynamic_objects += 0LLU;
6360463736 heap.availilable_size_for_dynamic_objects += 0LLU;
63605- state.addr = 18446744073709547869LLU; // 99999999Eb'''''''''''''''
63737+ state.addr = 18446744073709547853LLU; // 99999999EM'''''''''''''''
6360663738 break;
6360763739 }
63608- case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
63740+ case 18446744073709547856LLU: // 99999999EP'''''''''''''''
6360963741 {
6361063742 // ACCUMULATE ARGUMENTS - BEGIN
6361163743 {
@@ -63677,7 +63809,7 @@
6367763809 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6367863810 }
6367963811 // ACCUMULATE ARGUMENTS - END
63680- uint64_t return_to = 18446744073709547867LLU;
63812+ uint64_t return_to = 18446744073709547851LLU;
6368163813 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6368263814 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6368363815 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63686,17 +63818,17 @@
6368663818 state.addr = 787472338545441824LLU; // procrvalue
6368763819 break;
6368863820 }
63689- case 18446744073709547867LLU: // 99999999E$'''''''''''''''
63821+ case 18446744073709547851LLU: // 99999999EK'''''''''''''''
6369063822 {
63691- state.addr = 18446744073709547868LLU; // 99999999Ea'''''''''''''''
63823+ state.addr = 18446744073709547852LLU; // 99999999EL'''''''''''''''
6369263824 break;
6369363825 }
63694- case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
63826+ case 18446744073709547852LLU: // 99999999EL'''''''''''''''
6369563827 {
63696- state.addr = 18446744073709547869LLU; // 99999999Eb'''''''''''''''
63828+ state.addr = 18446744073709547853LLU; // 99999999EM'''''''''''''''
6369763829 break;
6369863830 }
63699- case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
63831+ case 18446744073709547853LLU: // 99999999EM'''''''''''''''
6370063832 {
6370163833 // variable u64 sym_______ goes out of scope
6370263834 // emitted destructur for type u64
@@ -63706,14 +63838,14 @@
6370663838 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference matchsym__ at 19
6370763839 // variable list<resdest___> newresults goes out of scope
6370863840 // emitted destructur for type list<resdest___>
63709- state.addr = 18446744073709547865LLU; // 99999999EY'''''''''''''''
63841+ state.addr = 18446744073709547849LLU; // 99999999EI'''''''''''''''
6371063842 break;
6371163843 }
63712- case 18446744073709547865LLU: // 99999999EY'''''''''''''''
63844+ case 18446744073709547849LLU: // 99999999EI'''''''''''''''
6371363845 {
6371463846 if(!*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/*list*/)
6371563847 {
63716- state.addr = 18446744073709547866LLU; // 99999999EZ'''''''''''''''
63848+ state.addr = 18446744073709547850LLU; // 99999999EJ'''''''''''''''
6371763849 break;
6371863850 }
6371963851 // temporary list-element
@@ -63727,7 +63859,7 @@
6372763859 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6372863860 }
6372963861 // ACCUMULATE ARGUMENTS - END
63730- uint64_t return_to = 18446744073709547864LLU;
63862+ uint64_t return_to = 18446744073709547848LLU;
6373163863 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6373263864 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6373363865 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63736,26 +63868,26 @@
6373663868 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6373763869 break;
6373863870 }
63739- case 18446744073709547864LLU: // 99999999EX'''''''''''''''
63871+ case 18446744073709547848LLU: // 99999999EH'''''''''''''''
6374063872 {
6374163873 // RELEASE temporary destructor-variable
6374263874 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
63743- state.addr = 18446744073709547865LLU; // 99999999EY'''''''''''''''
63875+ state.addr = 18446744073709547849LLU; // 99999999EI'''''''''''''''
6374463876 break;
6374563877 }
63746- case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
63878+ case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
6374763879 {
6374863880 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 18
6374963881 // variable list<resdest___> tmpresults goes out of scope
6375063882 // emitted destructur for type list<resdest___>
63751- state.addr = 18446744073709547862LLU; // 99999999EV'''''''''''''''
63883+ state.addr = 18446744073709547846LLU; // 99999999EF'''''''''''''''
6375263884 break;
6375363885 }
63754- case 18446744073709547862LLU: // 99999999EV'''''''''''''''
63886+ case 18446744073709547846LLU: // 99999999EF'''''''''''''''
6375563887 {
6375663888 if(!*LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/*list*/)
6375763889 {
63758- state.addr = 18446744073709547863LLU; // 99999999EW'''''''''''''''
63890+ state.addr = 18446744073709547847LLU; // 99999999EG'''''''''''''''
6375963891 break;
6376063892 }
6376163893 // temporary list-element
@@ -63769,7 +63901,7 @@
6376963901 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6377063902 }
6377163903 // ACCUMULATE ARGUMENTS - END
63772- uint64_t return_to = 18446744073709547861LLU;
63904+ uint64_t return_to = 18446744073709547845LLU;
6377363905 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6377463906 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6377563907 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63778,14 +63910,14 @@
6377863910 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6377963911 break;
6378063912 }
63781- case 18446744073709547861LLU: // 99999999EU'''''''''''''''
63913+ case 18446744073709547845LLU: // 99999999EE'''''''''''''''
6378263914 {
6378363915 // RELEASE temporary destructor-variable
6378463916 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
63785- state.addr = 18446744073709547862LLU; // 99999999EV'''''''''''''''
63917+ state.addr = 18446744073709547846LLU; // 99999999EF'''''''''''''''
6378663918 break;
6378763919 }
63788- case 18446744073709547863LLU: // 99999999EW'''''''''''''''
63920+ case 18446744073709547847LLU: // 99999999EG'''''''''''''''
6378963921 {
6379063922 (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpresults at 17
6379163923 // parameter-reference u64 remainheap goes out of scope
@@ -63841,7 +63973,7 @@
6384163973 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6384263974 }
6384363975 // ACCUMULATE ARGUMENTS - END
63844- uint64_t return_to = 18446744073709547859LLU;
63976+ uint64_t return_to = 18446744073709547843LLU;
6384563977 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6384663978 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6384763979 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63850,12 +63982,12 @@
6385063982 state.addr = 839519719621918720LLU; // skipws____
6385163983 break;
6385263984 }
63853- case 18446744073709547859LLU: // 99999999ES'''''''''''''''
63985+ case 18446744073709547843LLU: // 99999999EC'''''''''''''''
6385463986 {
63855- state.addr = 18446744073709547860LLU; // 99999999ET'''''''''''''''
63987+ state.addr = 18446744073709547844LLU; // 99999999ED'''''''''''''''
6385663988 break;
6385763989 }
63858- case 18446744073709547860LLU: // 99999999ET'''''''''''''''
63990+ case 18446744073709547844LLU: // 99999999ED'''''''''''''''
6385963991 {
6386063992 /*id________*/*LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU)));
6386163993 {
@@ -63885,7 +64017,7 @@
6388564017 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6388664018 }
6388764019 // ACCUMULATE ARGUMENTS - END
63888- uint64_t return_to = 18446744073709547857LLU;
64020+ uint64_t return_to = 18446744073709547841LLU;
6388964021 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6389064022 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6389164023 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63894,12 +64026,12 @@
6389464026 state.addr = 782701543487916768LLU; // parsemtype
6389564027 break;
6389664028 }
63897- case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
64029+ case 18446744073709547841LLU: // 99999999EA'''''''''''''''
6389864030 {
63899- state.addr = 18446744073709547858LLU; // 99999999ER'''''''''''''''
64031+ state.addr = 18446744073709547842LLU; // 99999999EB'''''''''''''''
6390064032 break;
6390164033 }
63902- case 18446744073709547858LLU: // 99999999ER'''''''''''''''
64034+ case 18446744073709547842LLU: // 99999999EB'''''''''''''''
6390364035 {
6390464036 // ACCUMULATE ARGUMENTS - BEGIN
6390564037 {
@@ -63907,7 +64039,7 @@
6390764039 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6390864040 }
6390964041 // ACCUMULATE ARGUMENTS - END
63910- uint64_t return_to = 18446744073709547855LLU;
64042+ uint64_t return_to = 18446744073709547839LLU;
6391164043 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6391264044 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6391364045 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63916,12 +64048,12 @@
6391664048 state.addr = 839519719621918720LLU; // skipws____
6391764049 break;
6391864050 }
63919- case 18446744073709547855LLU: // 99999999EO'''''''''''''''
64051+ case 18446744073709547839LLU: // 99999999D9'''''''''''''''
6392064052 {
63921- state.addr = 18446744073709547856LLU; // 99999999EP'''''''''''''''
64053+ state.addr = 18446744073709547840LLU; // 99999999E_'''''''''''''''
6392264054 break;
6392364055 }
63924- case 18446744073709547856LLU: // 99999999EP'''''''''''''''
64056+ case 18446744073709547840LLU: // 99999999E_'''''''''''''''
6392564057 {
6392664058 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
6392764059 {
@@ -63947,7 +64079,7 @@
6394764079 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6394864080 }
6394964081 // ACCUMULATE ARGUMENTS - END
63950- uint64_t return_to = 18446744073709547853LLU;
64082+ uint64_t return_to = 18446744073709547837LLU;
6395164083 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6395264084 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6395364085 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63956,17 +64088,17 @@
6395664088 state.addr = 696275824427849761LLU; // knowvarref
6395764089 break;
6395864090 }
63959- case 18446744073709547853LLU: // 99999999EM'''''''''''''''
64091+ case 18446744073709547837LLU: // 99999999D7'''''''''''''''
6396064092 {
63961- state.addr = 18446744073709547854LLU; // 99999999EN'''''''''''''''
64093+ state.addr = 18446744073709547838LLU; // 99999999D8'''''''''''''''
6396264094 break;
6396364095 }
63964- case 18446744073709547854LLU: // 99999999EN'''''''''''''''
64096+ case 18446744073709547838LLU: // 99999999D8'''''''''''''''
6396564097 {
63966- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547852LLU : 18446744073709547851LLU;
64098+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547836LLU : 18446744073709547835LLU;
6396764099 break;
6396864100 }
63969- case 18446744073709547852LLU: // 99999999EL'''''''''''''''
64101+ case 18446744073709547836LLU: // 99999999D6'''''''''''''''
6397064102 {
6397164103 {
6397264104 uint64_t arg = 0;
@@ -63979,7 +64111,7 @@
6397964111 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6398064112 }
6398164113 // ACCUMULATE ARGUMENTS - END
63982- uint64_t return_to = 18446744073709547849LLU;
64114+ uint64_t return_to = 18446744073709547833LLU;
6398364115 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6398464116 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6398564117 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -63988,12 +64120,12 @@
6398864120 state.addr = 839519719621918720LLU; // skipws____
6398964121 break;
6399064122 }
63991- case 18446744073709547849LLU: // 99999999EI'''''''''''''''
64123+ case 18446744073709547833LLU: // 99999999D3'''''''''''''''
6399264124 {
63993- state.addr = 18446744073709547850LLU; // 99999999EJ'''''''''''''''
64125+ state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
6399464126 break;
6399564127 }
63996- case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
64128+ case 18446744073709547834LLU: // 99999999D4'''''''''''''''
6399764129 {
6399864130 /*buf_______*/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 10LLU)));
6399964131 {
@@ -64002,17 +64134,17 @@
6400264134 }
6400364135 *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = 838639277163151360;
6400464136 /*shadow____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*buf_______*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) == /*shadow____*/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU);
64005- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547848LLU : 18446744073709547847LLU;
64137+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547832LLU : 18446744073709547831LLU;
6400664138 break;
6400764139 }
64008- case 18446744073709547848LLU: // 99999999EH'''''''''''''''
64140+ case 18446744073709547832LLU: // 99999999D2'''''''''''''''
6400964141 {
6401064142 heap.availilable_size_for_dynamic_objects += 0LLU;
6401164143 heap.availilable_size_for_dynamic_objects += 0LLU;
64012- state.addr = 18446744073709547846LLU; // 99999999EF'''''''''''''''
64144+ state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
6401364145 break;
6401464146 }
64015- case 18446744073709547847LLU: // 99999999EG'''''''''''''''
64147+ case 18446744073709547831LLU: // 99999999D1'''''''''''''''
6401664148 {
6401764149 // ACCUMULATE ARGUMENTS - BEGIN
6401864150 {
@@ -64020,7 +64152,7 @@
6402064152 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6402164153 }
6402264154 // ACCUMULATE ARGUMENTS - END
64023- uint64_t return_to = 18446744073709547844LLU;
64155+ uint64_t return_to = 18446744073709547828LLU;
6402464156 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6402564157 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6402664158 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64029,12 +64161,12 @@
6402964161 state.addr = 819847183515949359LLU; // reportinit
6403064162 break;
6403164163 }
64032- case 18446744073709547844LLU: // 99999999ED'''''''''''''''
64164+ case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
6403364165 {
64034- state.addr = 18446744073709547845LLU; // 99999999EE'''''''''''''''
64166+ state.addr = 18446744073709547829LLU; // 99999999Dz'''''''''''''''
6403564167 break;
6403664168 }
64037- case 18446744073709547845LLU: // 99999999EE'''''''''''''''
64169+ case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
6403864170 {
6403964171 fprintf(stderr, "%s", "variable ");
6404064172 printid(stderr, /*id________*/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU));
@@ -64044,10 +64176,10 @@
6404464176 fprintf(stderr, "%s\n", "");
6404564177 exit(-1);
6404664178 }
64047- state.addr = 18446744073709547846LLU; // 99999999EF'''''''''''''''
64179+ state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
6404864180 break;
6404964181 }
64050- case 18446744073709547846LLU: // 99999999EF'''''''''''''''
64182+ case 18446744073709547830LLU: // 99999999D0'''''''''''''''
6405164183 {
6405264184 // variable u64 shadow____ goes out of scope
6405364185 // emitted destructur for type u64
@@ -64055,10 +64187,10 @@
6405564187 // variable u64 buf_______ goes out of scope
6405664188 // emitted destructur for type u64
6405764189 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference buf_______ at 21
64058- state.addr = 18446744073709547851LLU; // 99999999EK'''''''''''''''
64190+ state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
6405964191 break;
6406064192 }
64061- case 18446744073709547851LLU: // 99999999EK'''''''''''''''
64193+ case 18446744073709547835LLU: // 99999999D5'''''''''''''''
6406264194 {
6406364195 // ACCUMULATE ARGUMENTS - BEGIN
6406464196 {
@@ -64082,7 +64214,7 @@
6408264214 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6408364215 }
6408464216 // ACCUMULATE ARGUMENTS - END
64085- uint64_t return_to = 18446744073709547842LLU;
64217+ uint64_t return_to = 18446744073709547826LLU;
6408664218 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6408764219 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6408864220 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64091,12 +64223,12 @@
6409164223 state.addr = 515555125197130432LLU; // allocheap_
6409264224 break;
6409364225 }
64094- case 18446744073709547842LLU: // 99999999EB'''''''''''''''
64226+ case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
6409564227 {
64096- state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
64228+ state.addr = 18446744073709547827LLU; // 99999999Dx'''''''''''''''
6409764229 break;
6409864230 }
64099- case 18446744073709547843LLU: // 99999999EC'''''''''''''''
64231+ case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
6410064232 {
6410164233 {
6410264234 uint64_t arg = 0;
@@ -64105,7 +64237,7 @@
6410564237 *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 0;
6410664238 // ACCUMULATE ARGUMENTS - BEGIN
6410764239 // ACCUMULATE ARGUMENTS - END
64108- uint64_t return_to = 18446744073709547839LLU;
64240+ uint64_t return_to = 18446744073709547823LLU;
6410964241 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0));
6411064242 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6411164243 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64114,12 +64246,12 @@
6411464246 state.addr = 890787671342055424LLU; // varopen___
6411564247 break;
6411664248 }
64117- case 18446744073709547839LLU: // 99999999D9'''''''''''''''
64249+ case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
6411864250 {
64119- state.addr = 18446744073709547840LLU; // 99999999E_'''''''''''''''
64251+ state.addr = 18446744073709547824LLU; // 99999999Du'''''''''''''''
6412064252 break;
6412164253 }
64122- case 18446744073709547840LLU: // 99999999E_'''''''''''''''
64254+ case 18446744073709547824LLU: // 99999999Du'''''''''''''''
6412364255 {
6412464256 fprintf(stdout, "%s", "0");
6412564257 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64144,7 +64276,7 @@
6414464276 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6414564277 }
6414664278 // ACCUMULATE ARGUMENTS - END
64147- uint64_t return_to = 18446744073709547837LLU;
64279+ uint64_t return_to = 18446744073709547821LLU;
6414864280 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6414964281 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6415064282 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64153,12 +64285,12 @@
6415364285 state.addr = 890786842582581248LLU; // varclose__
6415464286 break;
6415564287 }
64156- case 18446744073709547837LLU: // 99999999D7'''''''''''''''
64288+ case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
6415764289 {
64158- state.addr = 18446744073709547838LLU; // 99999999D8'''''''''''''''
64290+ state.addr = 18446744073709547822LLU; // 99999999Ds'''''''''''''''
6415964291 break;
6416064292 }
64161- case 18446744073709547838LLU: // 99999999D8'''''''''''''''
64293+ case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
6416264294 {
6416364295 // ACCUMULATE ARGUMENTS - BEGIN
6416464296 {
@@ -64166,7 +64298,7 @@
6416664298 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6416764299 }
6416864300 // ACCUMULATE ARGUMENTS - END
64169- uint64_t return_to = 18446744073709547835LLU;
64301+ uint64_t return_to = 18446744073709547819LLU;
6417064302 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6417164303 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6417264304 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64175,12 +64307,12 @@
6417564307 state.addr = 839519719621918720LLU; // skipws____
6417664308 break;
6417764309 }
64178- case 18446744073709547835LLU: // 99999999D5'''''''''''''''
64310+ case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
6417964311 {
64180- state.addr = 18446744073709547836LLU; // 99999999D6'''''''''''''''
64312+ state.addr = 18446744073709547820LLU; // 99999999Dq'''''''''''''''
6418164313 break;
6418264314 }
64183- case 18446744073709547836LLU: // 99999999D6'''''''''''''''
64315+ case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
6418464316 {
6418564317 {
6418664318 uint64_t arg = 0;
@@ -64206,7 +64338,7 @@
6420664338 LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6420764339 }
6420864340 // ACCUMULATE ARGUMENTS - END
64209- uint64_t return_to = 18446744073709547833LLU;
64341+ uint64_t return_to = 18446744073709547817LLU;
6421064342 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6421164343 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6421264344 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64215,17 +64347,17 @@
6421564347 state.addr = 728666047794575267LLU; // matchoptch
6421664348 break;
6421764349 }
64218- case 18446744073709547833LLU: // 99999999D3'''''''''''''''
64350+ case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
6421964351 {
64220- state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
64352+ state.addr = 18446744073709547818LLU; // 99999999Do'''''''''''''''
6422164353 break;
6422264354 }
64223- case 18446744073709547834LLU: // 99999999D4'''''''''''''''
64355+ case 18446744073709547818LLU: // 99999999Do'''''''''''''''
6422464356 {
64225- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547832LLU : 18446744073709547831LLU;
64357+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547816LLU : 18446744073709547815LLU;
6422664358 break;
6422764359 }
64228- case 18446744073709547832LLU: // 99999999D2'''''''''''''''
64360+ case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
6422964361 {
6423064362 {
6423164363 uint64_t arg = 0;
@@ -64246,7 +64378,7 @@
6424664378 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6424764379 }
6424864380 // ACCUMULATE ARGUMENTS - END
64249- uint64_t return_to = 18446744073709547829LLU;
64381+ uint64_t return_to = 18446744073709547813LLU;
6425064382 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6425164383 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6425264384 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64255,12 +64387,12 @@
6425564387 state.addr = 661640243165790208LLU; // islist____
6425664388 break;
6425764389 }
64258- case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
64390+ case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
6425964391 {
64260- state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
64392+ state.addr = 18446744073709547814LLU; // 99999999Dk'''''''''''''''
6426164393 break;
6426264394 }
64263- case 18446744073709547830LLU: // 99999999D0'''''''''''''''
64395+ case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
6426464396 {
6426564397 // ACCUMULATE ARGUMENTS - BEGIN
6426664398 {
@@ -64292,7 +64424,7 @@
6429264424 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6429364425 }
6429464426 // ACCUMULATE ARGUMENTS - END
64295- uint64_t return_to = 18446744073709547827LLU;
64427+ uint64_t return_to = 18446744073709547811LLU;
6429664428 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6429764429 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6429864430 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64301,12 +64433,12 @@
6430164433 state.addr = 788334703205941248LLU; // pushvar___
6430264434 break;
6430364435 }
64304- case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
64436+ case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
6430564437 {
64306- state.addr = 18446744073709547828LLU; // 99999999Dy'''''''''''''''
64438+ state.addr = 18446744073709547812LLU; // 99999999Di'''''''''''''''
6430764439 break;
6430864440 }
64309- case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
64441+ case 18446744073709547812LLU: // 99999999Di'''''''''''''''
6431064442 {
6431164443 // variable u64 initialize goes out of scope
6431264444 // emitted destructur for type u64
@@ -64316,10 +64448,10 @@
6431664448 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 24
6431764449 heap.availilable_size_for_dynamic_objects += 0LLU;
6431864450 heap.availilable_size_for_dynamic_objects += 0LLU;
64319- state.addr = 18446744073709547826LLU; // 99999999Dw'''''''''''''''
64451+ state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
6432064452 break;
6432164453 }
64322- case 18446744073709547831LLU: // 99999999D1'''''''''''''''
64454+ case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
6432364455 {
6432464456 matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 10LLU)));
6432564457 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64328,7 +64460,7 @@
6432864460 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6432964461 }
6433064462 // ACCUMULATE ARGUMENTS - END
64331- uint64_t return_to = 18446744073709547824LLU;
64463+ uint64_t return_to = 18446744073709547808LLU;
6433264464 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6433364465 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6433464466 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64337,20 +64469,20 @@
6433764469 state.addr = 839519719621918720LLU; // skipws____
6433864470 break;
6433964471 }
64340- case 18446744073709547824LLU: // 99999999Du'''''''''''''''
64472+ case 18446744073709547808LLU: // 99999999De'''''''''''''''
6434164473 {
64342- state.addr = 18446744073709547825LLU; // 99999999Dv'''''''''''''''
64474+ state.addr = 18446744073709547809LLU; // 99999999Df'''''''''''''''
6434364475 break;
6434464476 }
64345- case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
64477+ case 18446744073709547809LLU: // 99999999Df'''''''''''''''
6434664478 {
6434764479 *LOCAL_ACCESS(heap.data, 23LLU, 21LLU) = 123LLU;
6434864480
6434964481 /*match_____*/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 10LLU));
64350- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547823LLU : 18446744073709547822LLU;
64482+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547807LLU : 18446744073709547806LLU;
6435164483 break;
6435264484 }
64353- case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
64485+ case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
6435464486 {
6435564487 // ACCUMULATE ARGUMENTS - BEGIN
6435664488 {
@@ -64358,7 +64490,7 @@
6435864490 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6435964491 }
6436064492 // ACCUMULATE ARGUMENTS - END
64361- uint64_t return_to = 18446744073709547820LLU;
64493+ uint64_t return_to = 18446744073709547804LLU;
6436264494 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6436364495 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6436464496 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64367,12 +64499,12 @@
6436764499 state.addr = 819847183515949359LLU; // reportinit
6436864500 break;
6436964501 }
64370- case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
64502+ case 18446744073709547804LLU: // 99999999Da'''''''''''''''
6437164503 {
64372- state.addr = 18446744073709547821LLU; // 99999999Dr'''''''''''''''
64504+ state.addr = 18446744073709547805LLU; // 99999999Db'''''''''''''''
6437364505 break;
6437464506 }
64375- case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
64507+ case 18446744073709547805LLU: // 99999999Db'''''''''''''''
6437664508 {
6437764509 {
6437864510 fprintf(stderr, "%s\n", "let-initialization from block not implemented yet\n");
@@ -64380,10 +64512,10 @@
6438064512 }
6438164513 heap.availilable_size_for_dynamic_objects += 0LLU;
6438264514 heap.availilable_size_for_dynamic_objects += 0LLU;
64383- state.addr = 18446744073709547819LLU; // 99999999Dp'''''''''''''''
64515+ state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
6438464516 break;
6438564517 }
64386- case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
64518+ case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
6438764519 {
6438864520 {
6438964521 uint64_t arg = 0;
@@ -64412,7 +64544,7 @@
6441264544 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6441364545 }
6441464546 // ACCUMULATE ARGUMENTS - END
64415- uint64_t return_to = 18446744073709547817LLU;
64547+ uint64_t return_to = 18446744073709547801LLU;
6441664548 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6441764549 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6441864550 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64421,12 +64553,12 @@
6442164553 state.addr = 768289076452424640LLU; // oneresult_
6442264554 break;
6442364555 }
64424- case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
64556+ case 18446744073709547801LLU: // 99999999DY'''''''''''''''
6442564557 {
64426- state.addr = 18446744073709547818LLU; // 99999999Do'''''''''''''''
64558+ state.addr = 18446744073709547802LLU; // 99999999DZ'''''''''''''''
6442764559 break;
6442864560 }
64429- case 18446744073709547818LLU: // 99999999Do'''''''''''''''
64561+ case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
6443064562 {
6443164563 // ACCUMULATE ARGUMENTS - BEGIN
6443264564 {
@@ -64498,7 +64630,7 @@
6449864630 LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6449964631 }
6450064632 // ACCUMULATE ARGUMENTS - END
64501- uint64_t return_to = 18446744073709547815LLU;
64633+ uint64_t return_to = 18446744073709547799LLU;
6450264634 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0));
6450364635 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6450464636 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64507,12 +64639,12 @@
6450764639 state.addr = 787472338545441824LLU; // procrvalue
6450864640 break;
6450964641 }
64510- case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
64642+ case 18446744073709547799LLU: // 99999999DW'''''''''''''''
6451164643 {
64512- state.addr = 18446744073709547816LLU; // 99999999Dm'''''''''''''''
64644+ state.addr = 18446744073709547800LLU; // 99999999DX'''''''''''''''
6451364645 break;
6451464646 }
64515- case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
64647+ case 18446744073709547800LLU: // 99999999DX'''''''''''''''
6451664648 {
6451764649 {
6451864650 uint64_t arg = 0;
@@ -64549,7 +64681,7 @@
6454964681 LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6455064682 }
6455164683 // ACCUMULATE ARGUMENTS - END
64552- uint64_t return_to = 18446744073709547812LLU;
64684+ uint64_t return_to = 18446744073709547796LLU;
6455364685 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0));
6455464686 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6455564687 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64558,31 +64690,31 @@
6455864690 state.addr = 788334703205941248LLU; // pushvar___
6455964691 break;
6456064692 }
64561- case 18446744073709547812LLU: // 99999999Di'''''''''''''''
64693+ case 18446744073709547796LLU: // 99999999DT'''''''''''''''
6456264694 {
64563- state.addr = 18446744073709547813LLU; // 99999999Dj'''''''''''''''
64695+ state.addr = 18446744073709547797LLU; // 99999999DU'''''''''''''''
6456464696 break;
6456564697 }
64566- case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
64698+ case 18446744073709547797LLU: // 99999999DU'''''''''''''''
6456764699 {
6456864700 // variable u64 initialize goes out of scope
6456964701 // emitted destructur for type u64
6457064702 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 26
64571- state.addr = 18446744073709547814LLU; // 99999999Dk'''''''''''''''
64703+ state.addr = 18446744073709547798LLU; // 99999999DV'''''''''''''''
6457264704 break;
6457364705 }
64574- case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
64706+ case 18446744073709547798LLU: // 99999999DV'''''''''''''''
6457564707 {
6457664708 // variable list<resdest___> newresults goes out of scope
6457764709 // emitted destructur for type list<resdest___>
64578- state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
64710+ state.addr = 18446744073709547794LLU; // 99999999DR'''''''''''''''
6457964711 break;
6458064712 }
64581- case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
64713+ case 18446744073709547794LLU: // 99999999DR'''''''''''''''
6458264714 {
6458364715 if(!*LOCAL_ACCESS(heap.data, 25LLU, 24LLU)/*list*/)
6458464716 {
64585- state.addr = 18446744073709547811LLU; // 99999999Dh'''''''''''''''
64717+ state.addr = 18446744073709547795LLU; // 99999999DS'''''''''''''''
6458664718 break;
6458764719 }
6458864720 // temporary list-element
@@ -64596,7 +64728,7 @@
6459664728 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6459764729 }
6459864730 // ACCUMULATE ARGUMENTS - END
64599- uint64_t return_to = 18446744073709547809LLU;
64731+ uint64_t return_to = 18446744073709547793LLU;
6460064732 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6460164733 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6460264734 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64605,28 +64737,28 @@
6460564737 state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
6460664738 break;
6460764739 }
64608- case 18446744073709547809LLU: // 99999999Df'''''''''''''''
64740+ case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
6460964741 {
6461064742 // RELEASE temporary destructor-variable
6461164743 (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 26
64612- state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
64744+ state.addr = 18446744073709547794LLU; // 99999999DR'''''''''''''''
6461364745 break;
6461464746 }
64615- case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
64747+ case 18446744073709547795LLU: // 99999999DS'''''''''''''''
6461664748 {
6461764749 (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 25
6461864750 // variable u64 reference_ goes out of scope
6461964751 // emitted destructur for type u64
6462064752 (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 24
64621- state.addr = 18446744073709547819LLU; // 99999999Dp'''''''''''''''
64753+ state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
6462264754 break;
6462364755 }
64624- case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
64756+ case 18446744073709547803LLU: // 99999999D$'''''''''''''''
6462564757 {
64626- state.addr = 18446744073709547826LLU; // 99999999Dw'''''''''''''''
64758+ state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
6462764759 break;
6462864760 }
64629- case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
64761+ case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
6463064762 {
6463164763 // variable u64 match_____ goes out of scope
6463264764 // emitted destructur for type u64
@@ -64637,10 +64769,10 @@
6463764769 // variable u64 varidx____ goes out of scope
6463864770 // emitted destructur for type u64
6463964771 (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 21
64640- state.addr = 18446744073709547841LLU; // 99999999EA'''''''''''''''
64772+ state.addr = 18446744073709547825LLU; // 99999999Dv'''''''''''''''
6464164773 break;
6464264774 }
64643- case 18446744073709547841LLU: // 99999999EA'''''''''''''''
64775+ case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
6464464776 {
6464564777 // variable u64 redef_____ goes out of scope
6464664778 // emitted destructur for type u64
@@ -64653,7 +64785,7 @@
6465364785 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6465464786 }
6465564787 // ACCUMULATE ARGUMENTS - END
64656- uint64_t return_to = 18446744073709547808LLU;
64788+ uint64_t return_to = 18446744073709547792LLU;
6465764789 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6465864790 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6465964791 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64662,7 +64794,7 @@
6466264794 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6466364795 break;
6466464796 }
64665- case 18446744073709547808LLU: // 99999999De'''''''''''''''
64797+ case 18446744073709547792LLU: // 99999999DP'''''''''''''''
6466664798 {
6466764799 (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedst___ at 19
6466864800 // variable u64 mutable___ goes out of scope
@@ -64721,10 +64853,10 @@
6472164853 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 876383386118840320LLU;
6472264854
6472364855 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64724- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547807LLU : 18446744073709547806LLU;
64856+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547791LLU : 18446744073709547790LLU;
6472564857 break;
6472664858 }
64727- case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
64859+ case 18446744073709547791LLU: // 99999999DO'''''''''''''''
6472864860 {
6472964861 // ACCUMULATE ARGUMENTS - BEGIN
6473064862 {
@@ -64732,7 +64864,7 @@
6473264864 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6473364865 }
6473464866 // ACCUMULATE ARGUMENTS - END
64735- uint64_t return_to = 18446744073709547804LLU;
64867+ uint64_t return_to = 18446744073709547788LLU;
6473664868 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6473764869 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6473864870 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64741,12 +64873,12 @@
6474164873 state.addr = 839519719621918720LLU; // skipws____
6474264874 break;
6474364875 }
64744- case 18446744073709547804LLU: // 99999999Da'''''''''''''''
64876+ case 18446744073709547788LLU: // 99999999DL'''''''''''''''
6474564877 {
64746- state.addr = 18446744073709547805LLU; // 99999999Db'''''''''''''''
64878+ state.addr = 18446744073709547789LLU; // 99999999DM'''''''''''''''
6474764879 break;
6474864880 }
64749- case 18446744073709547805LLU: // 99999999Db'''''''''''''''
64881+ case 18446744073709547789LLU: // 99999999DM'''''''''''''''
6475064882 {
6475164883 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
6475264884 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64755,7 +64887,7 @@
6475564887 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6475664888 }
6475764889 // ACCUMULATE ARGUMENTS - END
64758- uint64_t return_to = 18446744073709547802LLU;
64890+ uint64_t return_to = 18446744073709547786LLU;
6475964891 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6476064892 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6476164893 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64764,12 +64896,12 @@
6476464896 state.addr = 839519719621918720LLU; // skipws____
6476564897 break;
6476664898 }
64767- case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
64899+ case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
6476864900 {
64769- state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
64901+ state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
6477064902 break;
6477164903 }
64772- case 18446744073709547803LLU: // 99999999D$'''''''''''''''
64904+ case 18446744073709547787LLU: // 99999999DK'''''''''''''''
6477364905 {
6477464906 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
6477564907 if(')' != (char)getchar())
@@ -64780,18 +64912,18 @@
6478064912 fprintf(stdout, "%s", "\n ungetc(0, stdin);");
6478164913 heap.availilable_size_for_dynamic_objects += 0LLU;
6478264914 heap.availilable_size_for_dynamic_objects += 0LLU;
64783- state.addr = 18446744073709547801LLU; // 99999999DY'''''''''''''''
64915+ state.addr = 18446744073709547785LLU; // 99999999DI'''''''''''''''
6478464916 break;
6478564917 }
64786- case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
64918+ case 18446744073709547790LLU: // 99999999DN'''''''''''''''
6478764919 {
6478864920 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 605666980531466240LLU;
6478964921
6479064922 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64791- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547800LLU : 18446744073709547799LLU;
64923+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547784LLU : 18446744073709547783LLU;
6479264924 break;
6479364925 }
64794- case 18446744073709547800LLU: // 99999999DX'''''''''''''''
64926+ case 18446744073709547784LLU: // 99999999DH'''''''''''''''
6479564927 {
6479664928 // ACCUMULATE ARGUMENTS - BEGIN
6479764929 {
@@ -64799,7 +64931,7 @@
6479964931 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6480064932 }
6480164933 // ACCUMULATE ARGUMENTS - END
64802- uint64_t return_to = 18446744073709547797LLU;
64934+ uint64_t return_to = 18446744073709547781LLU;
6480364935 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6480464936 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6480564937 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64808,12 +64940,12 @@
6480864940 state.addr = 839519719621918720LLU; // skipws____
6480964941 break;
6481064942 }
64811- case 18446744073709547797LLU: // 99999999DU'''''''''''''''
64943+ case 18446744073709547781LLU: // 99999999DE'''''''''''''''
6481264944 {
64813- state.addr = 18446744073709547798LLU; // 99999999DV'''''''''''''''
64945+ state.addr = 18446744073709547782LLU; // 99999999DF'''''''''''''''
6481464946 break;
6481564947 }
64816- case 18446744073709547798LLU: // 99999999DV'''''''''''''''
64948+ case 18446744073709547782LLU: // 99999999DF'''''''''''''''
6481764949 {
6481864950 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
6481964951 // ACCUMULATE ARGUMENTS - BEGIN
@@ -64822,7 +64954,7 @@
6482264954 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6482364955 }
6482464956 // ACCUMULATE ARGUMENTS - END
64825- uint64_t return_to = 18446744073709547795LLU;
64957+ uint64_t return_to = 18446744073709547779LLU;
6482664958 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6482764959 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6482864960 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64831,12 +64963,12 @@
6483164963 state.addr = 839519719621918720LLU; // skipws____
6483264964 break;
6483364965 }
64834- case 18446744073709547795LLU: // 99999999DS'''''''''''''''
64966+ case 18446744073709547779LLU: // 99999999DC'''''''''''''''
6483564967 {
64836- state.addr = 18446744073709547796LLU; // 99999999DT'''''''''''''''
64968+ state.addr = 18446744073709547780LLU; // 99999999DD'''''''''''''''
6483764969 break;
6483864970 }
64839- case 18446744073709547796LLU: // 99999999DT'''''''''''''''
64971+ case 18446744073709547780LLU: // 99999999DD'''''''''''''''
6484064972 {
6484164973 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
6484264974 if(')' != (char)getchar())
@@ -64847,20 +64979,20 @@
6484764979 fprintf(stdout, "%s", "\n fflush(stdout);");
6484864980 heap.availilable_size_for_dynamic_objects += 0LLU;
6484964981 heap.availilable_size_for_dynamic_objects += 0LLU;
64850- state.addr = 18446744073709547794LLU; // 99999999DR'''''''''''''''
64982+ state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
6485164983 break;
6485264984 }
64853- case 18446744073709547799LLU: // 99999999DW'''''''''''''''
64985+ case 18446744073709547783LLU: // 99999999DG'''''''''''''''
6485464986 {
64855- state.addr = 18446744073709547794LLU; // 99999999DR'''''''''''''''
64987+ state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
6485664988 break;
6485764989 }
64858- case 18446744073709547794LLU: // 99999999DR'''''''''''''''
64990+ case 18446744073709547778LLU: // 99999999DB'''''''''''''''
6485964991 {
64860- state.addr = 18446744073709547801LLU; // 99999999DY'''''''''''''''
64992+ state.addr = 18446744073709547785LLU; // 99999999DI'''''''''''''''
6486164993 break;
6486264994 }
64863- case 18446744073709547801LLU: // 99999999DY'''''''''''''''
64995+ case 18446744073709547785LLU: // 99999999DI'''''''''''''''
6486464996 {
6486564997 // variable u64 sym_______ goes out of scope
6486664998 // emitted destructur for type u64
@@ -64911,10 +65043,10 @@
6491165043 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183514351405LLU;
6491265044
6491365045 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64914- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547793LLU : 18446744073709547792LLU;
65046+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547777LLU : 18446744073709547776LLU;
6491565047 break;
6491665048 }
64917- case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
65049+ case 18446744073709547777LLU: // 99999999DA'''''''''''''''
6491865050 {
6491965051 {
6492065052 uint64_t arg = 0;
@@ -64936,7 +65068,7 @@
6493665068 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6493765069 }
6493865070 // ACCUMULATE ARGUMENTS - END
64939- uint64_t return_to = 18446744073709547790LLU;
65071+ uint64_t return_to = 18446744073709547774LLU;
6494065072 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6494165073 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6494265074 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64945,12 +65077,12 @@
6494565077 state.addr = 861504796319285248LLU; // typeu64___
6494665078 break;
6494765079 }
64948- case 18446744073709547790LLU: // 99999999DN'''''''''''''''
65080+ case 18446744073709547774LLU: // 99999999C8'''''''''''''''
6494965081 {
64950- state.addr = 18446744073709547791LLU; // 99999999DO'''''''''''''''
65082+ state.addr = 18446744073709547775LLU; // 99999999C9'''''''''''''''
6495165083 break;
6495265084 }
64953- case 18446744073709547791LLU: // 99999999DO'''''''''''''''
65085+ case 18446744073709547775LLU: // 99999999C9'''''''''''''''
6495465086 {
6495565087 // ACCUMULATE ARGUMENTS - BEGIN
6495665088 {
@@ -64958,7 +65090,7 @@
6495865090 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6495965091 }
6496065092 // ACCUMULATE ARGUMENTS - END
64961- uint64_t return_to = 18446744073709547788LLU;
65093+ uint64_t return_to = 18446744073709547772LLU;
6496265094 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6496365095 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6496465096 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64967,12 +65099,12 @@
6496765099 state.addr = 839519719621918720LLU; // skipws____
6496865100 break;
6496965101 }
64970- case 18446744073709547788LLU: // 99999999DL'''''''''''''''
65102+ case 18446744073709547772LLU: // 99999999C6'''''''''''''''
6497165103 {
64972- state.addr = 18446744073709547789LLU; // 99999999DM'''''''''''''''
65104+ state.addr = 18446744073709547773LLU; // 99999999C7'''''''''''''''
6497365105 break;
6497465106 }
64975- case 18446744073709547789LLU: // 99999999DM'''''''''''''''
65107+ case 18446744073709547773LLU: // 99999999C7'''''''''''''''
6497665108 {
6497765109 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6497865110 fprintf(stdout, "%s", "\n putc((char)");
@@ -64987,7 +65119,7 @@
6498765119 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6498865120 }
6498965121 // ACCUMULATE ARGUMENTS - END
64990- uint64_t return_to = 18446744073709547785LLU;
65122+ uint64_t return_to = 18446744073709547769LLU;
6499165123 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6499265124 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6499365125 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -64996,12 +65128,12 @@
6499665128 state.addr = 839519719621918720LLU; // skipws____
6499765129 break;
6499865130 }
64999- case 18446744073709547785LLU: // 99999999DI'''''''''''''''
65131+ case 18446744073709547769LLU: // 99999999C3'''''''''''''''
6500065132 {
65001- state.addr = 18446744073709547786LLU; // 99999999DJ'''''''''''''''
65133+ state.addr = 18446744073709547770LLU; // 99999999C4'''''''''''''''
6500265134 break;
6500365135 }
65004- case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
65136+ case 18446744073709547770LLU: // 99999999C4'''''''''''''''
6500565137 {
6500665138 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6500765139 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65022,7 +65154,7 @@
6502265154 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6502365155 }
6502465156 // ACCUMULATE ARGUMENTS - END
65025- uint64_t return_to = 18446744073709547783LLU;
65157+ uint64_t return_to = 18446744073709547767LLU;
6502665158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6502765159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6502865160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65031,12 +65163,12 @@
6503165163 state.addr = 517555565473470767LLU; // assertinit
6503265164 break;
6503365165 }
65034- case 18446744073709547783LLU: // 99999999DG'''''''''''''''
65166+ case 18446744073709547767LLU: // 99999999C1'''''''''''''''
6503565167 {
65036- state.addr = 18446744073709547784LLU; // 99999999DH'''''''''''''''
65168+ state.addr = 18446744073709547768LLU; // 99999999C2'''''''''''''''
6503765169 break;
6503865170 }
65039- case 18446744073709547784LLU: // 99999999DH'''''''''''''''
65171+ case 18446744073709547768LLU: // 99999999C2'''''''''''''''
6504065172 {
6504165173 {
6504265174 uint64_t arg = 0;
@@ -65115,7 +65247,7 @@
6511565247 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6511665248 }
6511765249 // ACCUMULATE ARGUMENTS - END
65118- uint64_t return_to = 18446744073709547781LLU;
65250+ uint64_t return_to = 18446744073709547765LLU;
6511965251 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6512065252 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6512165253 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65124,12 +65256,12 @@
6512465256 state.addr = 787472342492567585LLU; // procvarref
6512565257 break;
6512665258 }
65127- case 18446744073709547781LLU: // 99999999DE'''''''''''''''
65259+ case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
6512865260 {
65129- state.addr = 18446744073709547782LLU; // 99999999DF'''''''''''''''
65261+ state.addr = 18446744073709547766LLU; // 99999999C0'''''''''''''''
6513065262 break;
6513165263 }
65132- case 18446744073709547782LLU: // 99999999DF'''''''''''''''
65264+ case 18446744073709547766LLU: // 99999999C0'''''''''''''''
6513365265 {
6513465266 // variable u64 initialize goes out of scope
6513565267 // emitted destructur for type u64
@@ -65140,10 +65272,10 @@
6514065272 // variable u64 idx_______ goes out of scope
6514165273 // emitted destructur for type u64
6514265274 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65143- state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
65275+ state.addr = 18446744073709547771LLU; // 99999999C5'''''''''''''''
6514465276 break;
6514565277 }
65146- case 18446744073709547787LLU: // 99999999DK'''''''''''''''
65278+ case 18446744073709547771LLU: // 99999999C5'''''''''''''''
6514765279 {
6514865280 fprintf(stdout, "%s", ", stderr);");
6514965281 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65152,7 +65284,7 @@
6515265284 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6515365285 }
6515465286 // ACCUMULATE ARGUMENTS - END
65155- uint64_t return_to = 18446744073709547779LLU;
65287+ uint64_t return_to = 18446744073709547763LLU;
6515665288 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6515765289 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6515865290 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65161,12 +65293,12 @@
6516165293 state.addr = 839519719621918720LLU; // skipws____
6516265294 break;
6516365295 }
65164- case 18446744073709547779LLU: // 99999999DC'''''''''''''''
65296+ case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
6516565297 {
65166- state.addr = 18446744073709547780LLU; // 99999999DD'''''''''''''''
65298+ state.addr = 18446744073709547764LLU; // 99999999Cy'''''''''''''''
6516765299 break;
6516865300 }
65169- case 18446744073709547780LLU: // 99999999DD'''''''''''''''
65301+ case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
6517065302 {
6517165303 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6517265304 if(')' != (char)getchar())
@@ -65184,7 +65316,7 @@
6518465316 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6518565317 }
6518665318 // ACCUMULATE ARGUMENTS - END
65187- uint64_t return_to = 18446744073709547777LLU;
65319+ uint64_t return_to = 18446744073709547761LLU;
6518865320 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6518965321 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6519065322 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65193,12 +65325,12 @@
6519365325 state.addr = 517555565476695680LLU; // assertu64_
6519465326 break;
6519565327 }
65196- case 18446744073709547777LLU: // 99999999DA'''''''''''''''
65328+ case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
6519765329 {
65198- state.addr = 18446744073709547778LLU; // 99999999DB'''''''''''''''
65330+ state.addr = 18446744073709547762LLU; // 99999999Cw'''''''''''''''
6519965331 break;
6520065332 }
65201- case 18446744073709547778LLU: // 99999999DB'''''''''''''''
65333+ case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
6520265334 {
6520365335 // variable u64 mutable___ goes out of scope
6520465336 // emitted destructur for type u64
@@ -65211,7 +65343,7 @@
6521165343 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6521265344 }
6521365345 // ACCUMULATE ARGUMENTS - END
65214- uint64_t return_to = 18446744073709547776LLU;
65346+ uint64_t return_to = 18446744073709547760LLU;
6521565347 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6521665348 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6521765349 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65220,7 +65352,7 @@
6522065352 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6522165353 break;
6522265354 }
65223- case 18446744073709547776LLU: // 99999999D_'''''''''''''''
65355+ case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
6522465356 {
6522565357 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6522665358 // variable u64 INDIRECT__ goes out of scope
@@ -65231,18 +65363,18 @@
6523165363 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6523265364 heap.availilable_size_for_dynamic_objects += 0LLU;
6523365365 heap.availilable_size_for_dynamic_objects += 0LLU;
65234- state.addr = 18446744073709547775LLU; // 99999999C9'''''''''''''''
65366+ state.addr = 18446744073709547759LLU; // 99999999Ct'''''''''''''''
6523565367 break;
6523665368 }
65237- case 18446744073709547792LLU: // 99999999DP'''''''''''''''
65369+ case 18446744073709547776LLU: // 99999999D_'''''''''''''''
6523865370 {
6523965371 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708011125568LLU;
6524065372
6524165373 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65242- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547774LLU : 18446744073709547773LLU;
65374+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547758LLU : 18446744073709547757LLU;
6524365375 break;
6524465376 }
65245- case 18446744073709547774LLU: // 99999999C8'''''''''''''''
65377+ case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
6524665378 {
6524765379 {
6524865380 uint64_t arg = 0;
@@ -65264,7 +65396,7 @@
6526465396 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6526565397 }
6526665398 // ACCUMULATE ARGUMENTS - END
65267- uint64_t return_to = 18446744073709547771LLU;
65399+ uint64_t return_to = 18446744073709547755LLU;
6526865400 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6526965401 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6527065402 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65273,12 +65405,12 @@
6527365405 state.addr = 861504796319285248LLU; // typeu64___
6527465406 break;
6527565407 }
65276- case 18446744073709547771LLU: // 99999999C5'''''''''''''''
65408+ case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
6527765409 {
65278- state.addr = 18446744073709547772LLU; // 99999999C6'''''''''''''''
65410+ state.addr = 18446744073709547756LLU; // 99999999Cq'''''''''''''''
6527965411 break;
6528065412 }
65281- case 18446744073709547772LLU: // 99999999C6'''''''''''''''
65413+ case 18446744073709547756LLU: // 99999999Cq'''''''''''''''
6528265414 {
6528365415 // ACCUMULATE ARGUMENTS - BEGIN
6528465416 {
@@ -65286,7 +65418,7 @@
6528665418 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6528765419 }
6528865420 // ACCUMULATE ARGUMENTS - END
65289- uint64_t return_to = 18446744073709547769LLU;
65421+ uint64_t return_to = 18446744073709547753LLU;
6529065422 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6529165423 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6529265424 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65295,12 +65427,12 @@
6529565427 state.addr = 839519719621918720LLU; // skipws____
6529665428 break;
6529765429 }
65298- case 18446744073709547769LLU: // 99999999C3'''''''''''''''
65430+ case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
6529965431 {
65300- state.addr = 18446744073709547770LLU; // 99999999C4'''''''''''''''
65432+ state.addr = 18446744073709547754LLU; // 99999999Co'''''''''''''''
6530165433 break;
6530265434 }
65303- case 18446744073709547770LLU: // 99999999C4'''''''''''''''
65435+ case 18446744073709547754LLU: // 99999999Co'''''''''''''''
6530465436 {
6530565437 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6530665438 fprintf(stdout, "%s", "\n putc((char)");
@@ -65315,7 +65447,7 @@
6531565447 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6531665448 }
6531765449 // ACCUMULATE ARGUMENTS - END
65318- uint64_t return_to = 18446744073709547766LLU;
65450+ uint64_t return_to = 18446744073709547750LLU;
6531965451 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6532065452 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6532165453 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65324,12 +65456,12 @@
6532465456 state.addr = 839519719621918720LLU; // skipws____
6532565457 break;
6532665458 }
65327- case 18446744073709547766LLU: // 99999999C0'''''''''''''''
65459+ case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
6532865460 {
65329- state.addr = 18446744073709547767LLU; // 99999999C1'''''''''''''''
65461+ state.addr = 18446744073709547751LLU; // 99999999Cl'''''''''''''''
6533065462 break;
6533165463 }
65332- case 18446744073709547767LLU: // 99999999C1'''''''''''''''
65464+ case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
6533365465 {
6533465466 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6533565467 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65350,7 +65482,7 @@
6535065482 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6535165483 }
6535265484 // ACCUMULATE ARGUMENTS - END
65353- uint64_t return_to = 18446744073709547764LLU;
65485+ uint64_t return_to = 18446744073709547748LLU;
6535465486 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6535565487 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6535665488 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65359,12 +65491,12 @@
6535965491 state.addr = 517555565473470767LLU; // assertinit
6536065492 break;
6536165493 }
65362- case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
65494+ case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
6536365495 {
65364- state.addr = 18446744073709547765LLU; // 99999999Cz'''''''''''''''
65496+ state.addr = 18446744073709547749LLU; // 99999999Cj'''''''''''''''
6536565497 break;
6536665498 }
65367- case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
65499+ case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
6536865500 {
6536965501 {
6537065502 uint64_t arg = 0;
@@ -65443,7 +65575,7 @@
6544365575 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6544465576 }
6544565577 // ACCUMULATE ARGUMENTS - END
65446- uint64_t return_to = 18446744073709547762LLU;
65578+ uint64_t return_to = 18446744073709547746LLU;
6544765579 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6544865580 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6544965581 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65452,12 +65584,12 @@
6545265584 state.addr = 787472342492567585LLU; // procvarref
6545365585 break;
6545465586 }
65455- case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
65587+ case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
6545665588 {
65457- state.addr = 18446744073709547763LLU; // 99999999Cx'''''''''''''''
65589+ state.addr = 18446744073709547747LLU; // 99999999Ch'''''''''''''''
6545865590 break;
6545965591 }
65460- case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
65592+ case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
6546165593 {
6546265594 // variable u64 initialize goes out of scope
6546365595 // emitted destructur for type u64
@@ -65468,10 +65600,10 @@
6546865600 // variable u64 idx_______ goes out of scope
6546965601 // emitted destructur for type u64
6547065602 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65471- state.addr = 18446744073709547768LLU; // 99999999C2'''''''''''''''
65603+ state.addr = 18446744073709547752LLU; // 99999999Cm'''''''''''''''
6547265604 break;
6547365605 }
65474- case 18446744073709547768LLU: // 99999999C2'''''''''''''''
65606+ case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
6547565607 {
6547665608 fprintf(stdout, "%s", ", stdout);");
6547765609 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65480,7 +65612,7 @@
6548065612 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6548165613 }
6548265614 // ACCUMULATE ARGUMENTS - END
65483- uint64_t return_to = 18446744073709547760LLU;
65615+ uint64_t return_to = 18446744073709547744LLU;
6548465616 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6548565617 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6548665618 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65489,12 +65621,12 @@
6548965621 state.addr = 839519719621918720LLU; // skipws____
6549065622 break;
6549165623 }
65492- case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
65624+ case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
6549365625 {
65494- state.addr = 18446744073709547761LLU; // 99999999Cv'''''''''''''''
65626+ state.addr = 18446744073709547745LLU; // 99999999Cf'''''''''''''''
6549565627 break;
6549665628 }
65497- case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
65629+ case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
6549865630 {
6549965631 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6550065632 if(')' != (char)getchar())
@@ -65512,7 +65644,7 @@
6551265644 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6551365645 }
6551465646 // ACCUMULATE ARGUMENTS - END
65515- uint64_t return_to = 18446744073709547758LLU;
65647+ uint64_t return_to = 18446744073709547742LLU;
6551665648 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6551765649 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6551865650 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65521,12 +65653,12 @@
6552165653 state.addr = 517555565476695680LLU; // assertu64_
6552265654 break;
6552365655 }
65524- case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
65656+ case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
6552565657 {
65526- state.addr = 18446744073709547759LLU; // 99999999Ct'''''''''''''''
65658+ state.addr = 18446744073709547743LLU; // 99999999Cd'''''''''''''''
6552765659 break;
6552865660 }
65529- case 18446744073709547759LLU: // 99999999Ct'''''''''''''''
65661+ case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
6553065662 {
6553165663 // variable u64 mutable___ goes out of scope
6553265664 // emitted destructur for type u64
@@ -65539,7 +65671,7 @@
6553965671 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6554065672 }
6554165673 // ACCUMULATE ARGUMENTS - END
65542- uint64_t return_to = 18446744073709547757LLU;
65674+ uint64_t return_to = 18446744073709547741LLU;
6554365675 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6554465676 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6554565677 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65548,7 +65680,7 @@
6554865680 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6554965681 break;
6555065682 }
65551- case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
65683+ case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
6555265684 {
6555365685 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6555465686 // variable u64 INDIRECT__ goes out of scope
@@ -65559,18 +65691,18 @@
6555965691 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6556065692 heap.availilable_size_for_dynamic_objects += 0LLU;
6556165693 heap.availilable_size_for_dynamic_objects += 0LLU;
65562- state.addr = 18446744073709547756LLU; // 99999999Cq'''''''''''''''
65694+ state.addr = 18446744073709547740LLU; // 99999999Ca'''''''''''''''
6556365695 break;
6556465696 }
65565- case 18446744073709547773LLU: // 99999999C7'''''''''''''''
65697+ case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
6556665698 {
6556765699 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 621705556409974784LLU;
6556865700
6556965701 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65570- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547755LLU : 18446744073709547754LLU;
65702+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547739LLU : 18446744073709547738LLU;
6557165703 break;
6557265704 }
65573- case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
65705+ case 18446744073709547739LLU: // 99999999C$'''''''''''''''
6557465706 {
6557565707 {
6557665708 uint64_t arg = 0;
@@ -65592,7 +65724,7 @@
6559265724 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6559365725 }
6559465726 // ACCUMULATE ARGUMENTS - END
65595- uint64_t return_to = 18446744073709547752LLU;
65727+ uint64_t return_to = 18446744073709547736LLU;
6559665728 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6559765729 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6559865730 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65601,12 +65733,12 @@
6560165733 state.addr = 861504796319285248LLU; // typeu64___
6560265734 break;
6560365735 }
65604- case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
65736+ case 18446744073709547736LLU: // 99999999CX'''''''''''''''
6560565737 {
65606- state.addr = 18446744073709547753LLU; // 99999999Cn'''''''''''''''
65738+ state.addr = 18446744073709547737LLU; // 99999999CY'''''''''''''''
6560765739 break;
6560865740 }
65609- case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
65741+ case 18446744073709547737LLU: // 99999999CY'''''''''''''''
6561065742 {
6561165743 // ACCUMULATE ARGUMENTS - BEGIN
6561265744 {
@@ -65614,7 +65746,7 @@
6561465746 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6561565747 }
6561665748 // ACCUMULATE ARGUMENTS - END
65617- uint64_t return_to = 18446744073709547750LLU;
65749+ uint64_t return_to = 18446744073709547734LLU;
6561865750 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6561965751 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6562065752 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65623,12 +65755,12 @@
6562365755 state.addr = 839519719621918720LLU; // skipws____
6562465756 break;
6562565757 }
65626- case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
65758+ case 18446744073709547734LLU: // 99999999CV'''''''''''''''
6562765759 {
65628- state.addr = 18446744073709547751LLU; // 99999999Cl'''''''''''''''
65760+ state.addr = 18446744073709547735LLU; // 99999999CW'''''''''''''''
6562965761 break;
6563065762 }
65631- case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
65763+ case 18446744073709547735LLU: // 99999999CW'''''''''''''''
6563265764 {
6563365765 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6563465766 fprintf(stdout, "%s", "\n ");
@@ -65643,7 +65775,7 @@
6564365775 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6564465776 }
6564565777 // ACCUMULATE ARGUMENTS - END
65646- uint64_t return_to = 18446744073709547747LLU;
65778+ uint64_t return_to = 18446744073709547731LLU;
6564765779 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6564865780 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6564965781 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65652,12 +65784,12 @@
6565265784 state.addr = 839519719621918720LLU; // skipws____
6565365785 break;
6565465786 }
65655- case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
65787+ case 18446744073709547731LLU: // 99999999CS'''''''''''''''
6565665788 {
65657- state.addr = 18446744073709547748LLU; // 99999999Ci'''''''''''''''
65789+ state.addr = 18446744073709547732LLU; // 99999999CT'''''''''''''''
6565865790 break;
6565965791 }
65660- case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
65792+ case 18446744073709547732LLU: // 99999999CT'''''''''''''''
6566165793 {
6566265794 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6566365795 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65678,7 +65810,7 @@
6567865810 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6567965811 }
6568065812 // ACCUMULATE ARGUMENTS - END
65681- uint64_t return_to = 18446744073709547745LLU;
65813+ uint64_t return_to = 18446744073709547729LLU;
6568265814 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6568365815 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6568465816 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65687,12 +65819,12 @@
6568765819 state.addr = 517555565473470767LLU; // assertinit
6568865820 break;
6568965821 }
65690- case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
65822+ case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
6569165823 {
65692- state.addr = 18446744073709547746LLU; // 99999999Cg'''''''''''''''
65824+ state.addr = 18446744073709547730LLU; // 99999999CR'''''''''''''''
6569365825 break;
6569465826 }
65695- case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
65827+ case 18446744073709547730LLU: // 99999999CR'''''''''''''''
6569665828 {
6569765829 {
6569865830 uint64_t arg = 0;
@@ -65771,7 +65903,7 @@
6577165903 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6577265904 }
6577365905 // ACCUMULATE ARGUMENTS - END
65774- uint64_t return_to = 18446744073709547743LLU;
65906+ uint64_t return_to = 18446744073709547727LLU;
6577565907 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6577665908 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6577765909 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65780,12 +65912,12 @@
6578065912 state.addr = 787472342492567585LLU; // procvarref
6578165913 break;
6578265914 }
65783- case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
65915+ case 18446744073709547727LLU: // 99999999CO'''''''''''''''
6578465916 {
65785- state.addr = 18446744073709547744LLU; // 99999999Ce'''''''''''''''
65917+ state.addr = 18446744073709547728LLU; // 99999999CP'''''''''''''''
6578665918 break;
6578765919 }
65788- case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
65920+ case 18446744073709547728LLU: // 99999999CP'''''''''''''''
6578965921 {
6579065922 // variable u64 initialize goes out of scope
6579165923 // emitted destructur for type u64
@@ -65796,10 +65928,10 @@
6579665928 // variable u64 idx_______ goes out of scope
6579765929 // emitted destructur for type u64
6579865930 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
65799- state.addr = 18446744073709547749LLU; // 99999999Cj'''''''''''''''
65931+ state.addr = 18446744073709547733LLU; // 99999999CU'''''''''''''''
6580065932 break;
6580165933 }
65802- case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
65934+ case 18446744073709547733LLU: // 99999999CU'''''''''''''''
6580365935 {
6580465936 fprintf(stdout, "%s", " = (uint64_t)getchar();");
6580565937 // ACCUMULATE ARGUMENTS - BEGIN
@@ -65808,7 +65940,7 @@
6580865940 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6580965941 }
6581065942 // ACCUMULATE ARGUMENTS - END
65811- uint64_t return_to = 18446744073709547741LLU;
65943+ uint64_t return_to = 18446744073709547725LLU;
6581265944 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6581365945 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6581465946 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65817,12 +65949,12 @@
6581765949 state.addr = 839519719621918720LLU; // skipws____
6581865950 break;
6581965951 }
65820- case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
65952+ case 18446744073709547725LLU: // 99999999CM'''''''''''''''
6582165953 {
65822- state.addr = 18446744073709547742LLU; // 99999999Cc'''''''''''''''
65954+ state.addr = 18446744073709547726LLU; // 99999999CN'''''''''''''''
6582365955 break;
6582465956 }
65825- case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
65957+ case 18446744073709547726LLU: // 99999999CN'''''''''''''''
6582665958 {
6582765959 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6582865960 if(')' != (char)getchar())
@@ -65840,7 +65972,7 @@
6584065972 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6584165973 }
6584265974 // ACCUMULATE ARGUMENTS - END
65843- uint64_t return_to = 18446744073709547739LLU;
65975+ uint64_t return_to = 18446744073709547723LLU;
6584465976 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6584565977 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6584665978 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65849,12 +65981,12 @@
6584965981 state.addr = 517555565476695680LLU; // assertu64_
6585065982 break;
6585165983 }
65852- case 18446744073709547739LLU: // 99999999C$'''''''''''''''
65984+ case 18446744073709547723LLU: // 99999999CK'''''''''''''''
6585365985 {
65854- state.addr = 18446744073709547740LLU; // 99999999Ca'''''''''''''''
65986+ state.addr = 18446744073709547724LLU; // 99999999CL'''''''''''''''
6585565987 break;
6585665988 }
65857- case 18446744073709547740LLU: // 99999999Ca'''''''''''''''
65989+ case 18446744073709547724LLU: // 99999999CL'''''''''''''''
6585865990 {
6585965991 {
6586065992 uint64_t arg = 0;
@@ -65883,7 +66015,7 @@
6588366015 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6588466016 }
6588566017 // ACCUMULATE ARGUMENTS - END
65886- uint64_t return_to = 18446744073709547736LLU;
66018+ uint64_t return_to = 18446744073709547720LLU;
6588766019 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6588866020 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6588966021 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65892,20 +66024,20 @@
6589266024 state.addr = 734295421765213120LLU; // mutassert_
6589366025 break;
6589466026 }
65895- case 18446744073709547736LLU: // 99999999CX'''''''''''''''
66027+ case 18446744073709547720LLU: // 99999999CH'''''''''''''''
6589666028 {
65897- state.addr = 18446744073709547737LLU; // 99999999CY'''''''''''''''
66029+ state.addr = 18446744073709547721LLU; // 99999999CI'''''''''''''''
6589866030 break;
6589966031 }
65900- case 18446744073709547737LLU: // 99999999CY'''''''''''''''
66032+ case 18446744073709547721LLU: // 99999999CI'''''''''''''''
6590166033 {
6590266034 // variable u64 parnr_____ goes out of scope
6590366035 // emitted destructur for type u64
6590466036 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
65905- state.addr = 18446744073709547738LLU; // 99999999CZ'''''''''''''''
66037+ state.addr = 18446744073709547722LLU; // 99999999CJ'''''''''''''''
6590666038 break;
6590766039 }
65908- case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
66040+ case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
6590966041 {
6591066042 // variable u64 mutable___ goes out of scope
6591166043 // emitted destructur for type u64
@@ -65918,7 +66050,7 @@
6591866050 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6591966051 }
6592066052 // ACCUMULATE ARGUMENTS - END
65921- uint64_t return_to = 18446744073709547735LLU;
66053+ uint64_t return_to = 18446744073709547719LLU;
6592266054 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6592366055 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6592466056 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65927,7 +66059,7 @@
6592766059 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6592866060 break;
6592966061 }
65930- case 18446744073709547735LLU: // 99999999CW'''''''''''''''
66062+ case 18446744073709547719LLU: // 99999999CG'''''''''''''''
6593166063 {
6593266064 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6593366065 // variable u64 INDIRECT__ goes out of scope
@@ -65938,18 +66070,18 @@
6593866070 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6593966071 heap.availilable_size_for_dynamic_objects += 0LLU;
6594066072 heap.availilable_size_for_dynamic_objects += 0LLU;
65941- state.addr = 18446744073709547734LLU; // 99999999CV'''''''''''''''
66073+ state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
6594266074 break;
6594366075 }
65944- case 18446744073709547754LLU: // 99999999Co'''''''''''''''
66076+ case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
6594566077 {
6594666078 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 783769716797919232LLU;
6594766079
6594866080 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65949- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547733LLU : 18446744073709547732LLU;
66081+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547717LLU : 18446744073709547716LLU;
6595066082 break;
6595166083 }
65952- case 18446744073709547733LLU: // 99999999CU'''''''''''''''
66084+ case 18446744073709547717LLU: // 99999999CE'''''''''''''''
6595366085 {
6595466086 {
6595566087 uint64_t arg = 0;
@@ -65971,7 +66103,7 @@
6597166103 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6597266104 }
6597366105 // ACCUMULATE ARGUMENTS - END
65974- uint64_t return_to = 18446744073709547730LLU;
66106+ uint64_t return_to = 18446744073709547714LLU;
6597566107 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6597666108 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6597766109 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -65980,12 +66112,12 @@
6598066112 state.addr = 861504796319285248LLU; // typeu64___
6598166113 break;
6598266114 }
65983- case 18446744073709547730LLU: // 99999999CR'''''''''''''''
66115+ case 18446744073709547714LLU: // 99999999CB'''''''''''''''
6598466116 {
65985- state.addr = 18446744073709547731LLU; // 99999999CS'''''''''''''''
66117+ state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
6598666118 break;
6598766119 }
65988- case 18446744073709547731LLU: // 99999999CS'''''''''''''''
66120+ case 18446744073709547715LLU: // 99999999CC'''''''''''''''
6598966121 {
6599066122 // ACCUMULATE ARGUMENTS - BEGIN
6599166123 {
@@ -65993,7 +66125,7 @@
6599366125 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6599466126 }
6599566127 // ACCUMULATE ARGUMENTS - END
65996- uint64_t return_to = 18446744073709547728LLU;
66128+ uint64_t return_to = 18446744073709547712LLU;
6599766129 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6599866130 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6599966131 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66002,12 +66134,12 @@
6600266134 state.addr = 839519719621918720LLU; // skipws____
6600366135 break;
6600466136 }
66005- case 18446744073709547728LLU: // 99999999CP'''''''''''''''
66137+ case 18446744073709547712LLU: // 99999999C_'''''''''''''''
6600666138 {
66007- state.addr = 18446744073709547729LLU; // 99999999CQ'''''''''''''''
66139+ state.addr = 18446744073709547713LLU; // 99999999CA'''''''''''''''
6600866140 break;
6600966141 }
66010- case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
66142+ case 18446744073709547713LLU: // 99999999CA'''''''''''''''
6601166143 {
6601266144 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6601366145 fprintf(stdout, "%s", "\n ");
@@ -66022,7 +66154,7 @@
6602266154 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6602366155 }
6602466156 // ACCUMULATE ARGUMENTS - END
66025- uint64_t return_to = 18446744073709547725LLU;
66157+ uint64_t return_to = 18446744073709547709LLU;
6602666158 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6602766159 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6602866160 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66031,12 +66163,12 @@
6603166163 state.addr = 839519719621918720LLU; // skipws____
6603266164 break;
6603366165 }
66034- case 18446744073709547725LLU: // 99999999CM'''''''''''''''
66166+ case 18446744073709547709LLU: // 99999999B7'''''''''''''''
6603566167 {
66036- state.addr = 18446744073709547726LLU; // 99999999CN'''''''''''''''
66168+ state.addr = 18446744073709547710LLU; // 99999999B8'''''''''''''''
6603766169 break;
6603866170 }
66039- case 18446744073709547726LLU: // 99999999CN'''''''''''''''
66171+ case 18446744073709547710LLU: // 99999999B8'''''''''''''''
6604066172 {
6604166173 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6604266174 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66057,7 +66189,7 @@
6605766189 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6605866190 }
6605966191 // ACCUMULATE ARGUMENTS - END
66060- uint64_t return_to = 18446744073709547723LLU;
66192+ uint64_t return_to = 18446744073709547707LLU;
6606166193 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6606266194 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6606366195 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66066,12 +66198,12 @@
6606666198 state.addr = 517555565473470767LLU; // assertinit
6606766199 break;
6606866200 }
66069- case 18446744073709547723LLU: // 99999999CK'''''''''''''''
66201+ case 18446744073709547707LLU: // 99999999B5'''''''''''''''
6607066202 {
66071- state.addr = 18446744073709547724LLU; // 99999999CL'''''''''''''''
66203+ state.addr = 18446744073709547708LLU; // 99999999B6'''''''''''''''
6607266204 break;
6607366205 }
66074- case 18446744073709547724LLU: // 99999999CL'''''''''''''''
66206+ case 18446744073709547708LLU: // 99999999B6'''''''''''''''
6607566207 {
6607666208 {
6607766209 uint64_t arg = 0;
@@ -66150,7 +66282,7 @@
6615066282 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6615166283 }
6615266284 // ACCUMULATE ARGUMENTS - END
66153- uint64_t return_to = 18446744073709547721LLU;
66285+ uint64_t return_to = 18446744073709547705LLU;
6615466286 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6615566287 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6615666288 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66159,12 +66291,12 @@
6615966291 state.addr = 787472342492567585LLU; // procvarref
6616066292 break;
6616166293 }
66162- case 18446744073709547721LLU: // 99999999CI'''''''''''''''
66294+ case 18446744073709547705LLU: // 99999999B3'''''''''''''''
6616366295 {
66164- state.addr = 18446744073709547722LLU; // 99999999CJ'''''''''''''''
66296+ state.addr = 18446744073709547706LLU; // 99999999B4'''''''''''''''
6616566297 break;
6616666298 }
66167- case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
66299+ case 18446744073709547706LLU: // 99999999B4'''''''''''''''
6616866300 {
6616966301 // variable u64 initialize goes out of scope
6617066302 // emitted destructur for type u64
@@ -66175,10 +66307,10 @@
6617566307 // variable u64 idx_______ goes out of scope
6617666308 // emitted destructur for type u64
6617766309 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66178- state.addr = 18446744073709547727LLU; // 99999999CO'''''''''''''''
66310+ state.addr = 18446744073709547711LLU; // 99999999B9'''''''''''''''
6617966311 break;
6618066312 }
66181- case 18446744073709547727LLU: // 99999999CO'''''''''''''''
66313+ case 18446744073709547711LLU: // 99999999B9'''''''''''''''
6618266314 {
6618366315 fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
6618466316 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66187,7 +66319,7 @@
6618766319 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6618866320 }
6618966321 // ACCUMULATE ARGUMENTS - END
66190- uint64_t return_to = 18446744073709547719LLU;
66322+ uint64_t return_to = 18446744073709547703LLU;
6619166323 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6619266324 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6619366325 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66196,12 +66328,12 @@
6619666328 state.addr = 839519719621918720LLU; // skipws____
6619766329 break;
6619866330 }
66199- case 18446744073709547719LLU: // 99999999CG'''''''''''''''
66331+ case 18446744073709547703LLU: // 99999999B1'''''''''''''''
6620066332 {
66201- state.addr = 18446744073709547720LLU; // 99999999CH'''''''''''''''
66333+ state.addr = 18446744073709547704LLU; // 99999999B2'''''''''''''''
6620266334 break;
6620366335 }
66204- case 18446744073709547720LLU: // 99999999CH'''''''''''''''
66336+ case 18446744073709547704LLU: // 99999999B2'''''''''''''''
6620566337 {
6620666338 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6620766339 if(')' != (char)getchar())
@@ -66219,7 +66351,7 @@
6621966351 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6622066352 }
6622166353 // ACCUMULATE ARGUMENTS - END
66222- uint64_t return_to = 18446744073709547717LLU;
66354+ uint64_t return_to = 18446744073709547701LLU;
6622366355 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6622466356 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6622566357 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66228,12 +66360,12 @@
6622866360 state.addr = 517555565476695680LLU; // assertu64_
6622966361 break;
6623066362 }
66231- case 18446744073709547717LLU: // 99999999CE'''''''''''''''
66363+ case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
6623266364 {
66233- state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
66365+ state.addr = 18446744073709547702LLU; // 99999999B0'''''''''''''''
6623466366 break;
6623566367 }
66236- case 18446744073709547718LLU: // 99999999CF'''''''''''''''
66368+ case 18446744073709547702LLU: // 99999999B0'''''''''''''''
6623766369 {
6623866370 {
6623966371 uint64_t arg = 0;
@@ -66262,7 +66394,7 @@
6626266394 LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6626366395 }
6626466396 // ACCUMULATE ARGUMENTS - END
66265- uint64_t return_to = 18446744073709547714LLU;
66397+ uint64_t return_to = 18446744073709547698LLU;
6626666398 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6626766399 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6626866400 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66271,20 +66403,20 @@
6627166403 state.addr = 734295421765213120LLU; // mutassert_
6627266404 break;
6627366405 }
66274- case 18446744073709547714LLU: // 99999999CB'''''''''''''''
66406+ case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
6627566407 {
66276- state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
66408+ state.addr = 18446744073709547699LLU; // 99999999Bx'''''''''''''''
6627766409 break;
6627866410 }
66279- case 18446744073709547715LLU: // 99999999CC'''''''''''''''
66411+ case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
6628066412 {
6628166413 // variable u64 parnr_____ goes out of scope
6628266414 // emitted destructur for type u64
6628366415 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20
66284- state.addr = 18446744073709547716LLU; // 99999999CD'''''''''''''''
66416+ state.addr = 18446744073709547700LLU; // 99999999By'''''''''''''''
6628566417 break;
6628666418 }
66287- case 18446744073709547716LLU: // 99999999CD'''''''''''''''
66419+ case 18446744073709547700LLU: // 99999999By'''''''''''''''
6628866420 {
6628966421 // variable u64 mutable___ goes out of scope
6629066422 // emitted destructur for type u64
@@ -66297,7 +66429,7 @@
6629766429 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6629866430 }
6629966431 // ACCUMULATE ARGUMENTS - END
66300- uint64_t return_to = 18446744073709547713LLU;
66432+ uint64_t return_to = 18446744073709547697LLU;
6630166433 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6630266434 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6630366435 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66306,7 +66438,7 @@
6630666438 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6630766439 break;
6630866440 }
66309- case 18446744073709547713LLU: // 99999999CA'''''''''''''''
66441+ case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
6631066442 {
6631166443 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6631266444 // variable u64 INDIRECT__ goes out of scope
@@ -66317,18 +66449,18 @@
6631766449 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6631866450 heap.availilable_size_for_dynamic_objects += 0LLU;
6631966451 heap.availilable_size_for_dynamic_objects += 0LLU;
66320- state.addr = 18446744073709547712LLU; // 99999999C_'''''''''''''''
66452+ state.addr = 18446744073709547696LLU; // 99999999Bu'''''''''''''''
6632166453 break;
6632266454 }
66323- case 18446744073709547732LLU: // 99999999CT'''''''''''''''
66455+ case 18446744073709547716LLU: // 99999999CD'''''''''''''''
6632466456 {
6632566457 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708110622720LLU;
6632666458
6632766459 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66328- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547711LLU : 18446744073709547710LLU;
66460+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547695LLU : 18446744073709547694LLU;
6632966461 break;
6633066462 }
66331- case 18446744073709547711LLU: // 99999999B9'''''''''''''''
66463+ case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
6633266464 {
6633366465 {
6633466466 uint64_t arg = 0;
@@ -66350,7 +66482,7 @@
6635066482 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6635166483 }
6635266484 // ACCUMULATE ARGUMENTS - END
66353- uint64_t return_to = 18446744073709547708LLU;
66485+ uint64_t return_to = 18446744073709547692LLU;
6635466486 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6635566487 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6635666488 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66359,12 +66491,12 @@
6635966491 state.addr = 861504796319285248LLU; // typeu64___
6636066492 break;
6636166493 }
66362- case 18446744073709547708LLU: // 99999999B6'''''''''''''''
66494+ case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
6636366495 {
66364- state.addr = 18446744073709547709LLU; // 99999999B7'''''''''''''''
66496+ state.addr = 18446744073709547693LLU; // 99999999Br'''''''''''''''
6636566497 break;
6636666498 }
66367- case 18446744073709547709LLU: // 99999999B7'''''''''''''''
66499+ case 18446744073709547693LLU: // 99999999Br'''''''''''''''
6636866500 {
6636966501 // ACCUMULATE ARGUMENTS - BEGIN
6637066502 {
@@ -66372,7 +66504,7 @@
6637266504 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6637366505 }
6637466506 // ACCUMULATE ARGUMENTS - END
66375- uint64_t return_to = 18446744073709547706LLU;
66507+ uint64_t return_to = 18446744073709547690LLU;
6637666508 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6637766509 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6637866510 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66381,12 +66513,12 @@
6638166513 state.addr = 839519719621918720LLU; // skipws____
6638266514 break;
6638366515 }
66384- case 18446744073709547706LLU: // 99999999B4'''''''''''''''
66516+ case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
6638566517 {
66386- state.addr = 18446744073709547707LLU; // 99999999B5'''''''''''''''
66518+ state.addr = 18446744073709547691LLU; // 99999999Bp'''''''''''''''
6638766519 break;
6638866520 }
66389- case 18446744073709547707LLU: // 99999999B5'''''''''''''''
66521+ case 18446744073709547691LLU: // 99999999Bp'''''''''''''''
6639066522 {
6639166523 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6639266524 fprintf(stdout, "%s", "\n printid(stdout, ");
@@ -66401,7 +66533,7 @@
6640166533 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6640266534 }
6640366535 // ACCUMULATE ARGUMENTS - END
66404- uint64_t return_to = 18446744073709547703LLU;
66536+ uint64_t return_to = 18446744073709547687LLU;
6640566537 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6640666538 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6640766539 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66410,12 +66542,12 @@
6641066542 state.addr = 839519719621918720LLU; // skipws____
6641166543 break;
6641266544 }
66413- case 18446744073709547703LLU: // 99999999B1'''''''''''''''
66545+ case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
6641466546 {
66415- state.addr = 18446744073709547704LLU; // 99999999B2'''''''''''''''
66547+ state.addr = 18446744073709547688LLU; // 99999999Bm'''''''''''''''
6641666548 break;
6641766549 }
66418- case 18446744073709547704LLU: // 99999999B2'''''''''''''''
66550+ case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
6641966551 {
6642066552 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6642166553 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66436,7 +66568,7 @@
6643666568 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6643766569 }
6643866570 // ACCUMULATE ARGUMENTS - END
66439- uint64_t return_to = 18446744073709547701LLU;
66571+ uint64_t return_to = 18446744073709547685LLU;
6644066572 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6644166573 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6644266574 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66445,12 +66577,12 @@
6644566577 state.addr = 517555565473470767LLU; // assertinit
6644666578 break;
6644766579 }
66448- case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
66580+ case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
6644966581 {
66450- state.addr = 18446744073709547702LLU; // 99999999B0'''''''''''''''
66582+ state.addr = 18446744073709547686LLU; // 99999999Bk'''''''''''''''
6645166583 break;
6645266584 }
66453- case 18446744073709547702LLU: // 99999999B0'''''''''''''''
66585+ case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
6645466586 {
6645566587 {
6645666588 uint64_t arg = 0;
@@ -66529,7 +66661,7 @@
6652966661 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6653066662 }
6653166663 // ACCUMULATE ARGUMENTS - END
66532- uint64_t return_to = 18446744073709547699LLU;
66664+ uint64_t return_to = 18446744073709547683LLU;
6653366665 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6653466666 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6653566667 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66538,12 +66670,12 @@
6653866670 state.addr = 787472342492567585LLU; // procvarref
6653966671 break;
6654066672 }
66541- case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
66673+ case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
6654266674 {
66543- state.addr = 18446744073709547700LLU; // 99999999By'''''''''''''''
66675+ state.addr = 18446744073709547684LLU; // 99999999Bi'''''''''''''''
6654466676 break;
6654566677 }
66546- case 18446744073709547700LLU: // 99999999By'''''''''''''''
66678+ case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
6654766679 {
6654866680 // variable u64 initialize goes out of scope
6654966681 // emitted destructur for type u64
@@ -66554,10 +66686,10 @@
6655466686 // variable u64 idx_______ goes out of scope
6655566687 // emitted destructur for type u64
6655666688 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66557- state.addr = 18446744073709547705LLU; // 99999999B3'''''''''''''''
66689+ state.addr = 18446744073709547689LLU; // 99999999Bn'''''''''''''''
6655866690 break;
6655966691 }
66560- case 18446744073709547705LLU: // 99999999B3'''''''''''''''
66692+ case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
6656166693 {
6656266694 fprintf(stdout, "%s", ");");
6656366695 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66566,7 +66698,7 @@
6656666698 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6656766699 }
6656866700 // ACCUMULATE ARGUMENTS - END
66569- uint64_t return_to = 18446744073709547697LLU;
66701+ uint64_t return_to = 18446744073709547681LLU;
6657066702 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6657166703 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6657266704 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66575,12 +66707,12 @@
6657566707 state.addr = 839519719621918720LLU; // skipws____
6657666708 break;
6657766709 }
66578- case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
66710+ case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
6657966711 {
66580- state.addr = 18446744073709547698LLU; // 99999999Bw'''''''''''''''
66712+ state.addr = 18446744073709547682LLU; // 99999999Bg'''''''''''''''
6658166713 break;
6658266714 }
66583- case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
66715+ case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
6658466716 {
6658566717 ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
6658666718 if(')' != (char)getchar())
@@ -66598,7 +66730,7 @@
6659866730 LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6659966731 }
6660066732 // ACCUMULATE ARGUMENTS - END
66601- uint64_t return_to = 18446744073709547695LLU;
66733+ uint64_t return_to = 18446744073709547679LLU;
6660266734 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6660366735 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6660466736 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66607,12 +66739,12 @@
6660766739 state.addr = 517555565476695680LLU; // assertu64_
6660866740 break;
6660966741 }
66610- case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
66742+ case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
6661166743 {
66612- state.addr = 18446744073709547696LLU; // 99999999Bu'''''''''''''''
66744+ state.addr = 18446744073709547680LLU; // 99999999Be'''''''''''''''
6661366745 break;
6661466746 }
66615- case 18446744073709547696LLU: // 99999999Bu'''''''''''''''
66747+ case 18446744073709547680LLU: // 99999999Be'''''''''''''''
6661666748 {
6661766749 // variable u64 mutable___ goes out of scope
6661866750 // emitted destructur for type u64
@@ -66625,7 +66757,7 @@
6662566757 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6662666758 }
6662766759 // ACCUMULATE ARGUMENTS - END
66628- uint64_t return_to = 18446744073709547694LLU;
66760+ uint64_t return_to = 18446744073709547678LLU;
6662966761 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6663066762 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6663166763 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66634,7 +66766,7 @@
6663466766 state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
6663566767 break;
6663666768 }
66637- case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
66769+ case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
6663866770 {
6663966771 (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18
6664066772 // variable u64 INDIRECT__ goes out of scope
@@ -66645,18 +66777,18 @@
6664566777 (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16
6664666778 heap.availilable_size_for_dynamic_objects += 0LLU;
6664766779 heap.availilable_size_for_dynamic_objects += 0LLU;
66648- state.addr = 18446744073709547693LLU; // 99999999Br'''''''''''''''
66780+ state.addr = 18446744073709547677LLU; // 99999999Bb'''''''''''''''
6664966781 break;
6665066782 }
66651- case 18446744073709547710LLU: // 99999999B8'''''''''''''''
66783+ case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
6665266784 {
6665366785 *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183515906048LLU;
6665466786
6665566787 /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66656- state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547692LLU : 18446744073709547691LLU;
66788+ state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547676LLU : 18446744073709547675LLU;
6665766789 break;
6665866790 }
66659- case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
66791+ case 18446744073709547676LLU: // 99999999Ba'''''''''''''''
6666066792 {
6666166793 {
6666266794 uint64_t arg = 0;
@@ -66678,7 +66810,7 @@
6667866810 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6667966811 }
6668066812 // ACCUMULATE ARGUMENTS - END
66681- uint64_t return_to = 18446744073709547689LLU;
66813+ uint64_t return_to = 18446744073709547673LLU;
6668266814 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6668366815 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6668466816 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66687,12 +66819,12 @@
6668766819 state.addr = 861504796319285248LLU; // typeu64___
6668866820 break;
6668966821 }
66690- case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
66822+ case 18446744073709547673LLU: // 99999999BY'''''''''''''''
6669166823 {
66692- state.addr = 18446744073709547690LLU; // 99999999Bo'''''''''''''''
66824+ state.addr = 18446744073709547674LLU; // 99999999BZ'''''''''''''''
6669366825 break;
6669466826 }
66695- case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
66827+ case 18446744073709547674LLU: // 99999999BZ'''''''''''''''
6669666828 {
6669766829 // ACCUMULATE ARGUMENTS - BEGIN
6669866830 {
@@ -66700,7 +66832,7 @@
6670066832 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6670166833 }
6670266834 // ACCUMULATE ARGUMENTS - END
66703- uint64_t return_to = 18446744073709547687LLU;
66835+ uint64_t return_to = 18446744073709547671LLU;
6670466836 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6670566837 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6670666838 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66709,12 +66841,12 @@
6670966841 state.addr = 839519719621918720LLU; // skipws____
6671066842 break;
6671166843 }
66712- case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
66844+ case 18446744073709547671LLU: // 99999999BW'''''''''''''''
6671366845 {
66714- state.addr = 18446744073709547688LLU; // 99999999Bm'''''''''''''''
66846+ state.addr = 18446744073709547672LLU; // 99999999BX'''''''''''''''
6671566847 break;
6671666848 }
66717- case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
66849+ case 18446744073709547672LLU: // 99999999BX'''''''''''''''
6671866850 {
6671966851 matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
6672066852 fprintf(stdout, "%s", "\n printid(stderr, ");
@@ -66729,7 +66861,7 @@
6672966861 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6673066862 }
6673166863 // ACCUMULATE ARGUMENTS - END
66732- uint64_t return_to = 18446744073709547684LLU;
66864+ uint64_t return_to = 18446744073709547668LLU;
6673366865 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6673466866 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6673566867 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66738,12 +66870,12 @@
6673866870 state.addr = 839519719621918720LLU; // skipws____
6673966871 break;
6674066872 }
66741- case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
66873+ case 18446744073709547668LLU: // 99999999BT'''''''''''''''
6674266874 {
66743- state.addr = 18446744073709547685LLU; // 99999999Bj'''''''''''''''
66875+ state.addr = 18446744073709547669LLU; // 99999999BU'''''''''''''''
6674466876 break;
6674566877 }
66746- case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
66878+ case 18446744073709547669LLU: // 99999999BU'''''''''''''''
6674766879 {
6674866880 /*id________*/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
6674966881 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66764,7 +66896,7 @@
6676466896 LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6676566897 }
6676666898 // ACCUMULATE ARGUMENTS - END
66767- uint64_t return_to = 18446744073709547682LLU;
66899+ uint64_t return_to = 18446744073709547666LLU;
6676866900 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6676966901 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6677066902 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66773,12 +66905,12 @@
6677366905 state.addr = 517555565473470767LLU; // assertinit
6677466906 break;
6677566907 }
66776- case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
66908+ case 18446744073709547666LLU: // 99999999BR'''''''''''''''
6677766909 {
66778- state.addr = 18446744073709547683LLU; // 99999999Bh'''''''''''''''
66910+ state.addr = 18446744073709547667LLU; // 99999999BS'''''''''''''''
6677966911 break;
6678066912 }
66781- case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
66913+ case 18446744073709547667LLU: // 99999999BS'''''''''''''''
6678266914 {
6678366915 {
6678466916 uint64_t arg = 0;
@@ -66857,7 +66989,7 @@
6685766989 LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6685866990 }
6685966991 // ACCUMULATE ARGUMENTS - END
66860- uint64_t return_to = 18446744073709547680LLU;
66992+ uint64_t return_to = 18446744073709547664LLU;
6686166993 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0));
6686266994 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6686366995 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66866,12 +66998,12 @@
6686666998 state.addr = 787472342492567585LLU; // procvarref
6686766999 break;
6686867000 }
66869- case 18446744073709547680LLU: // 99999999Be'''''''''''''''
67001+ case 18446744073709547664LLU: // 99999999BP'''''''''''''''
6687067002 {
66871- state.addr = 18446744073709547681LLU; // 99999999Bf'''''''''''''''
67003+ state.addr = 18446744073709547665LLU; // 99999999BQ'''''''''''''''
6687267004 break;
6687367005 }
66874- case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
67006+ case 18446744073709547665LLU: // 99999999BQ'''''''''''''''
6687567007 {
6687667008 // variable u64 initialize goes out of scope
6687767009 // emitted destructur for type u64
@@ -66882,10 +67014,10 @@
6688267014 // variable u64 idx_______ goes out of scope
6688367015 // emitted destructur for type u64
6688467016 (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20
66885- state.addr = 18446744073709547686LLU; // 99999999Bk'''''''''''''''
67017+ state.addr = 18446744073709547670LLU; // 99999999BV'''''''''''''''
6688667018 break;
6688767019 }
66888- case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
67020+ case 18446744073709547670LLU: // 99999999BV'''''''''''''''
6688967021 {
6689067022 fprintf(stdout, "%s", ");");
6689167023 // ACCUMULATE ARGUMENTS - BEGIN
@@ -66894,7 +67026,7 @@
6689467026 LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6689567027 }
6689667028 // ACCUMULATE ARGUMENTS - END
66897- uint64_t return_to = 18446744073709547678LLU;
67029+ uint64_t return_to = 18446744073709547662LLU;
6689867030 const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6689967031 uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6690067032 *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
@@ -66903,12 +67035,12 @@
6690367035 state.addr = 839519719621918720LLU; // skipws____
6690467036 break;
6690567037 }
66906- case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
67038+ case 18446744073709547662LLU: // 99999999BN'''''''''''''''
6690767039 {
66908- state.addr = 18446744073709547679LLU; // 99999999Bd'''''''''''''''
67040+ state.addr = 18446744073709547663LLU; // 99999999BO'''''''''''''''
6690967041 break;
6691067042 }
66911- case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
67043+ case 18446744073709547663LLU: // 99999999BO''''''