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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	979 (tree)
Time	2020-04-26 08:50:48
Author	jakobthomsen

Log Message

assignment copies primitives, moves compounds

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (revision 978)

+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (revision 979)

		@@ -560,9 +560,9 @@
560	560	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
561	561	}
562	562	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /value_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
563		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	563	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
564	564	// variable u64 result____ goes out of scope
565		- // (uninitialized -> no destructor-call)
	565	+ // emitted destructur for type u64
566	566	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
567	567	// parameter-reference u64 value_____ goes out of scope
568	568	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference value_____ at 2

		@@ -583,9 +583,9 @@
583	583	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
584	584	}
585	585	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /value_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
586		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	586	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
587	587	// variable u64 result____ goes out of scope
588		- // (uninitialized -> no destructor-call)
	588	+ // emitted destructur for type u64
589	589	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
590	590	// parameter-reference u64 value_____ goes out of scope
591	591	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference value_____ at 2

		@@ -644,9 +644,9 @@
644	644	}
645	645	case 18446744073709551613LLU: // 9999999997'''''''''''''''
646	646	{
647		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	647	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
648	648	// variable u64 result____ goes out of scope
649		- // (uninitialized -> no destructor-call)
	649	+ // emitted destructur for type u64
650	650	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
651	651	// parameter-reference u64 lookahead_ goes out of scope
652	652	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -678,9 +678,9 @@
678	678	}
679	679	case 18446744073709551611LLU: // 9999999995'''''''''''''''
680	680	{
681		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	681	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
682	682	// variable u64 result____ goes out of scope
683		- // (uninitialized -> no destructor-call)
	683	+ // emitted destructur for type u64
684	684	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
685	685	// parameter-reference u64 lookahead_ goes out of scope
686	686	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -912,9 +912,9 @@
912	912	}
913	913	case 18446744073709551598LLU: // 999999999s'''''''''''''''
914	914	{
915		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	915	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
916	916	// variable u64 result____ goes out of scope
917		- // (uninitialized -> no destructor-call)
	917	+ // emitted destructur for type u64
918	918	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
919	919	// parameter-reference u64 lookahead_ goes out of scope
920	920	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -985,9 +985,9 @@
985	985	}
986	986	case 18446744073709551589LLU: // 999999999j'''''''''''''''
987	987	{
988		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	988	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
989	989	// variable u64 result____ goes out of scope
990		- // (uninitialized -> no destructor-call)
	990	+ // emitted destructur for type u64
991	991	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
992	992	// parameter-reference u64 lookahead_ goes out of scope
993	993	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -1110,9 +1110,9 @@
1110	1110	}
1111	1111	case 18446744073709551578LLU: // 999999999Z'''''''''''''''
1112	1112	{
1113		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	1113	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1114	1114	// variable u64 result____ goes out of scope
1115		- // (uninitialized -> no destructor-call)
	1115	+ // emitted destructur for type u64
1116	1116	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
1117	1117	// parameter-reference u64 lookahead_ goes out of scope
1118	1118	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -1182,9 +1182,9 @@
1182	1182	}
1183	1183	case 18446744073709551571LLU: // 999999999S'''''''''''''''
1184	1184	{
1185		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	1185	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1186	1186	// variable u64 result____ goes out of scope
1187		- // (uninitialized -> no destructor-call)
	1187	+ // emitted destructur for type u64
1188	1188	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
1189	1189	// parameter-reference u64 lookahead_ goes out of scope
1190	1190	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 2

		@@ -7275,9 +7275,9 @@
7275	7275	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
7276	7276	}
7277	7277	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU));
7278		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	7278	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7279	7279	// variable u64 result____ goes out of scope
7280		- // (uninitialized -> no destructor-call)
	7280	+ // emitted destructur for type u64
7281	7281	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
7282	7282	// parameter-reference function__ fn________ goes out of scope
7283	7283	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fn________ at 2

		@@ -7297,9 +7297,9 @@
7297	7297	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
7298	7298	}
7299	7299	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 5LLU));
7300		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	7300	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7301	7301	// variable u64 result____ goes out of scope
7302		- // (uninitialized -> no destructor-call)
	7302	+ // emitted destructur for type u64
7303	7303	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
7304	7304	// parameter-reference function__ fn________ goes out of scope
7305	7305	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fn________ at 2

		@@ -7319,9 +7319,9 @@
7319	7319	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
7320	7320	}
7321	7321	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 6LLU));
7322		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	7322	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7323	7323	// variable u64 result____ goes out of scope
7324		- // (uninitialized -> no destructor-call)
	7324	+ // emitted destructur for type u64
7325	7325	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
7326	7326	// parameter-reference function__ fn________ goes out of scope
7327	7327	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fn________ at 2

		@@ -12099,9 +12099,9 @@
12099	12099	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
12100	12100	}
12101	12101	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU));
12102		- swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	12102	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
12103	12103	// variable u64 result____ goes out of scope
12104		- // (uninitialized -> no destructor-call)
	12104	+ // emitted destructur for type u64
12105	12105	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
12106	12106	// parameter-reference defidfn___ fn________ goes out of scope
12107	12107	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fn________ at 2

		@@ -16353,12 +16353,12 @@
16353	16353	}
16354	16354	case 18446744073709550618LLU: // 99999999uZ'''''''''''''''
16355	16355	{
16356		- swap(&LOCAL_ACCESS(heap.data, 6LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
	16356	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = /sizeonheap/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
16357	16357	// variable u64 notfound__ goes out of scope
16358	16358	// emitted destructur for type u64
16359	16359	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference notfound__ at 6
16360	16360	// variable u64 sizeonheap goes out of scope
16361		- // (uninitialized -> no destructor-call)
	16361	+ // emitted destructur for type u64
16362	16362	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 5
16363	16363	// parameter-reference u64 id________ goes out of scope
16364	16364	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 4

		@@ -21129,12 +21129,12 @@
21129	21129	}
21130	21130	case 18446744073709550338LLU: // 99999999qB'''''''''''''''
21131	21131	{
21132		- swap(&LOCAL_ACCESS(heap.data, 4LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
	21132	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
21133	21133	// variable u64 sym_______ goes out of scope
21134	21134	// emitted destructur for type u64
21135	21135	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 4
21136	21136	// variable u64 result____ goes out of scope
21137		- // (uninitialized -> no destructor-call)
	21137	+ // emitted destructur for type u64
21138	21138	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
21139	21139	// parameter-reference u64 c_________ goes out of scope
21140	21140	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference c_________ at 2

		@@ -21440,12 +21440,12 @@
21440	21440	}
21441	21441	case 18446744073709550309LLU: // 99999999pj'''''''''''''''
21442	21442	{
21443		- swap(&LOCAL_ACCESS(heap.data, 4LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
	21443	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /result____/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
21444	21444	// variable u64 sym_______ goes out of scope
21445	21445	// emitted destructur for type u64
21446	21446	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 4
21447	21447	// variable u64 result____ goes out of scope
21448		- // (uninitialized -> no destructor-call)
	21448	+ // emitted destructur for type u64
21449	21449	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 3
21450	21450	// parameter-reference u64 c_________ goes out of scope
21451	21451	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference c_________ at 2

		@@ -73802,9 +73802,9 @@
73802	73802	}
73803	73803	case 18446744073709546900LLU: // 999999980T'''''''''''''''
73804	73804	{
73805		- swap(&LOCAL_ACCESS(heap.data, 25LLU, 24LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 0LLU))); // result
	73805	+ access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 0LLU)) = /called____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU);
73806	73806	// variable u64 called____ goes out of scope
73807		- // (uninitialized -> no destructor-call)
	73807	+ // emitted destructur for type u64
73808	73808	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference called____ at 25
73809	73809	// parameter-reference u64 remainheap goes out of scope
73810	73810	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainheap at 24

		@@ -78986,12 +78986,6 @@
78986	78986	fprintf(stdout, "%s", " = ");
78987	78987	fprintf(stdout, "%llu", (unsigned long long)/nr________/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU));
78988	78988	fprintf(stdout, "%s", ";");
78989		- ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stdin);
78990		- if(';' != (char)getchar())
78991		- {
78992		- fprintf(stderr, "match failed at char %c\n", (char)59LLU);
78993		- exit(-1);
78994		- }
78995	78989	state.addr = 18446744073709546587LLU; // 99999998v$'''''''''''''''
78996	78990	break;
78997	78991	}

		@@ -79852,13 +79846,49 @@
79852	79846	}
79853	79847	case 18446744073709546542LLU: // 99999998us'''''''''''''''
79854	79848	{
	79849	+ {
	79850	+ uint64_t arg = 0;
	79851	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	79852	+ }
79855	79853	// ACCUMULATE ARGUMENTS - BEGIN
79856	79854	{
	79855	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	79856	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	79857	+ }
	79858	+ {
	79859	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU), 0LLU);
	79860	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	79861	+ }
	79862	+ // ACCUMULATE ARGUMENTS - END
	79863	+ uint64_t return_to = 18446744073709546519LLU;
	79864	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	79865	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	79866	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	79867	+ heap.data[0].elem1 = heap.data[0].elem0;
	79868	+ heap.data[0].elem0 = restore;
	79869	+ state.addr = 661640243165790208LLU; // islist____
	79870	+ break;
	79871	+ }
	79872	+ case 18446744073709546519LLU: // 99999998uW'''''''''''''''
	79873	+ {
	79874	+ state.addr = 18446744073709546520LLU; // 99999998uX'''''''''''''''
	79875	+ break;
	79876	+ }
	79877	+ case 18446744073709546520LLU: // 99999998uX'''''''''''''''
	79878	+ {
	79879	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546522LLU : 18446744073709546521LLU;
	79880	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
	79881	+ break;
	79882	+ }
	79883	+ case 18446744073709546522LLU: // 99999998uZ'''''''''''''''
	79884	+ {
	79885	+ // ACCUMULATE ARGUMENTS - BEGIN
	79886	+ {
79857	79887	uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 21LLU, 0LLU);
79858	79888	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
79859	79889	}
79860	79890	// ACCUMULATE ARGUMENTS - END
79861		- uint64_t return_to = 18446744073709546521LLU;
	79891	+ uint64_t return_to = 18446744073709546517LLU;
79862	79892	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
79863	79893	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
79864	79894	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -79867,12 +79897,12 @@
79867	79897	state.addr = 819847183515949359LLU; // reportinit
79868	79898	break;
79869	79899	}
79870		- case 18446744073709546521LLU: // 99999998uY'''''''''''''''
	79900	+ case 18446744073709546517LLU: // 99999998uU'''''''''''''''
79871	79901	{
79872		- state.addr = 18446744073709546522LLU; // 99999998uZ'''''''''''''''
	79902	+ state.addr = 18446744073709546518LLU; // 99999998uV'''''''''''''''
79873	79903	break;
79874	79904	}
79875		- case 18446744073709546522LLU: // 99999998uZ'''''''''''''''
	79905	+ case 18446744073709546518LLU: // 99999998uV'''''''''''''''
79876	79906	{
79877	79907	fprintf(stderr, "%s", "can only assign to u64 but found ");
79878	79908	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -79881,7 +79911,7 @@
79881	79911	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
79882	79912	}
79883	79913	// ACCUMULATE ARGUMENTS - END
79884		- uint64_t return_to = 18446744073709546519LLU;
	79914	+ uint64_t return_to = 18446744073709546515LLU;
79885	79915	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
79886	79916	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
79887	79917	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -79890,28 +79920,430 @@
79890	79920	state.addr = 819847183518878432LLU; // reporttype
79891	79921	break;
79892	79922	}
79893		- case 18446744073709546519LLU: // 99999998uW'''''''''''''''
	79923	+ case 18446744073709546515LLU: // 99999998uS'''''''''''''''
79894	79924	{
79895		- state.addr = 18446744073709546520LLU; // 99999998uX'''''''''''''''
	79925	+ state.addr = 18446744073709546516LLU; // 99999998uT'''''''''''''''
79896	79926	break;
79897	79927	}
79898		- case 18446744073709546520LLU: // 99999998uX'''''''''''''''
	79928	+ case 18446744073709546516LLU: // 99999998uT'''''''''''''''
79899	79929	{
79900	79930	{
79901	79931	fprintf(stderr, "%s\n", "");
79902	79932	exit(-1);
79903	79933	}
	79934	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	79935	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	79936	+ state.addr = 18446744073709546514LLU; // 99999998uR'''''''''''''''
	79937	+ break;
	79938	+ }
	79939	+ case 18446744073709546521LLU: // 99999998uY'''''''''''''''
	79940	+ {
	79941	+ state.addr = 18446744073709546514LLU; // 99999998uR'''''''''''''''
	79942	+ break;
	79943	+ }
	79944	+ case 18446744073709546514LLU: // 99999998uR'''''''''''''''
	79945	+ {
	79946	+ fprintf(stdout, "%s", "\n swap(&");
	79947	+ {
	79948	+ uint64_t arg = 0;
	79949	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	79950	+ }
	79951	+ // ACCUMULATE ARGUMENTS - BEGIN
	79952	+ {
	79953	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	79954	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	79955	+ }
	79956	+ // ACCUMULATE ARGUMENTS - END
	79957	+ uint64_t return_to = 18446744073709546512LLU;
	79958	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	79959	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	79960	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	79961	+ heap.data[0].elem1 = heap.data[0].elem0;
	79962	+ heap.data[0].elem0 = restore;
	79963	+ state.addr = 861504796319285248LLU; // typeu64___
	79964	+ break;
	79965	+ }
	79966	+ case 18446744073709546512LLU: // 99999998uP'''''''''''''''
	79967	+ {
	79968	+ state.addr = 18446744073709546513LLU; // 99999998uQ'''''''''''''''
	79969	+ break;
	79970	+ }
	79971	+ case 18446744073709546513LLU: // 99999998uQ'''''''''''''''
	79972	+ {
	79973	+ {
	79974	+ uint64_t arg = 0;
	79975	+ LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
	79976	+ }
	79977	+ *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0;
	79978	+ {
	79979	+ uint64_t arg = 0;
	79980	+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/address of current closure/, &arg);
	79981	+ }
	79982	+ *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = 0;
	79983	+ {
	79984	+ uint64_t arg = 0;
	79985	+ LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
	79986	+ }
	79987	+ *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = 0;
	79988	+ {
	79989	+ uint64_t arg = 0;
	79990	+ LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/address of current closure/, &arg);
	79991	+ }
	79992	+ *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = 0;
	79993	+ {
	79994	+ uint64_t arg = 0;
	79995	+ LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
	79996	+ }
	79997	+ *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = 0;
	79998	+ {
	79999	+ uint64_t arg = 0;
	80000	+ LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
	80001	+ }
	80002	+ *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 0;
	80003	+ {
	80004	+ uint64_t arg = 0;
	80005	+ LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/address of current closure/, &arg);
	80006	+ }
	80007	+ *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = 0;
	80008	+ // ACCUMULATE ARGUMENTS - BEGIN
	80009	+ {
	80010	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
	80011	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80012	+ }
	80013	+ {
	80014	+ uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU);
	80015	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80016	+ }
	80017	+ {
	80018	+ uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU);
	80019	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80020	+ }
	80021	+ {
	80022	+ uint64_t arg = /callee_id_/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU);
	80023	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80024	+ }
	80025	+ {
	80026	+ uint64_t arg = /idx_______/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU);
	80027	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80028	+ }
	80029	+ {
	80030	+ uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU);
	80031	+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80032	+ }
	80033	+ {
	80034	+ uint64_t arg = /typesrc___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 21LLU);
	80035	+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80036	+ }
	80037	+ {
	80038	+ uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU);
	80039	+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80040	+ }
	80041	+ {
	80042	+ uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 25LLU);
	80043	+ LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80044	+ }
	80045	+ {
	80046	+ uint64_t arg = /init1_____/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU);
	80047	+ LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80048	+ }
	80049	+ {
	80050	+ uint64_t arg = /optelem___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 27LLU);
	80051	+ LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80052	+ }
	80053	+ {
	80054	+ uint64_t arg = /consume___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU);
	80055	+ LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80056	+ }
	80057	+ // ACCUMULATE ARGUMENTS - END
	80058	+ uint64_t return_to = 18446744073709546509LLU;
	80059	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
	80060	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80061	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80062	+ heap.data[0].elem1 = heap.data[0].elem0;
	80063	+ heap.data[0].elem0 = restore;
	80064	+ state.addr = 604790753280317473LLU; // findvarref
	80065	+ break;
	80066	+ }
	80067	+ case 18446744073709546509LLU: // 99999998uM'''''''''''''''
	80068	+ {
	80069	+ state.addr = 18446744073709546510LLU; // 99999998uN'''''''''''''''
	80070	+ break;
	80071	+ }
	80072	+ case 18446744073709546510LLU: // 99999998uN'''''''''''''''
	80073	+ {
	80074	+ // ACCUMULATE ARGUMENTS - BEGIN
	80075	+ {
	80076	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU);
	80077	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80078	+ }
	80079	+ {
	80080	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU);
	80081	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80082	+ }
	80083	+ {
	80084	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU);
	80085	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80086	+ }
	80087	+ {
	80088	+ uint64_t arg = /idx_______/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU);
	80089	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80090	+ }
	80091	+ {
	80092	+ uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU);
	80093	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80094	+ }
	80095	+ // ACCUMULATE ARGUMENTS - END
	80096	+ uint64_t return_to = 18446744073709546507LLU;
	80097	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
	80098	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80099	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80100	+ heap.data[0].elem1 = heap.data[0].elem0;
	80101	+ heap.data[0].elem0 = restore;
	80102	+ state.addr = 587881357514113024LLU; // emitpar___
	80103	+ break;
	80104	+ }
	80105	+ case 18446744073709546507LLU: // 99999998uK'''''''''''''''
	80106	+ {
	80107	+ state.addr = 18446744073709546508LLU; // 99999998uL'''''''''''''''
	80108	+ break;
	80109	+ }
	80110	+ case 18446744073709546508LLU: // 99999998uL'''''''''''''''
	80111	+ {
	80112	+ // variable u64 consume___ goes out of scope
	80113	+ // emitted destructur for type u64
	80114	+ (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference consume___ at 29
	80115	+ // variable u64 optelem___ goes out of scope
	80116	+ // emitted destructur for type u64
	80117	+ (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 28
	80118	+ state.addr = 18446744073709546511LLU; // 99999998uO'''''''''''''''
	80119	+ break;
	80120	+ }
	80121	+ case 18446744073709546511LLU: // 99999998uO'''''''''''''''
	80122	+ {
	80123	+ // ACCUMULATE ARGUMENTS - BEGIN
	80124	+ {
	80125	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
	80126	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80127	+ }
	80128	+ {
	80129	+ uint64_t arg = /callee_id_/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 19LLU);
	80130	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80131	+ }
	80132	+ {
	80133	+ uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU);
	80134	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80135	+ }
	80136	+ {
	80137	+ uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU);
	80138	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80139	+ }
	80140	+ {
	80141	+ uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 25LLU);
	80142	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80143	+ }
	80144	+ // ACCUMULATE ARGUMENTS - END
	80145	+ uint64_t return_to = 18446744073709546505LLU;
	80146	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
	80147	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80148	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80149	+ heap.data[0].elem1 = heap.data[0].elem0;
	80150	+ heap.data[0].elem0 = restore;
	80151	+ state.addr = 842862227159939072LLU; // swappable_
	80152	+ break;
	80153	+ }
	80154	+ case 18446744073709546505LLU: // 99999998uI'''''''''''''''
	80155	+ {
	80156	+ state.addr = 18446744073709546506LLU; // 99999998uJ'''''''''''''''
	80157	+ break;
	80158	+ }
	80159	+ case 18446744073709546506LLU: // 99999998uJ'''''''''''''''
	80160	+ {
	80161	+ {
	80162	+ uint64_t arg = 0;
	80163	+ LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
	80164	+ }
	80165	+ *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 819865187908583424;
	80166	+ // ACCUMULATE ARGUMENTS - BEGIN
	80167	+ {
	80168	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
	80169	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80170	+ }
	80171	+ {
	80172	+ uint64_t arg = /info______/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
	80173	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80174	+ }
	80175	+ {
	80176	+ uint64_t arg = /init1_____/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU);
	80177	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80178	+ }
	80179	+ {
	80180	+ uint64_t arg = /callee_id_/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
	80181	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80182	+ }
	80183	+ // ACCUMULATE ARGUMENTS - END
	80184	+ uint64_t return_to = 18446744073709546503LLU;
	80185	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
	80186	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80187	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80188	+ heap.data[0].elem1 = heap.data[0].elem0;
	80189	+ heap.data[0].elem0 = restore;
	80190	+ state.addr = 660220410725010287LLU; // initassert
	80191	+ break;
	80192	+ }
	80193	+ case 18446744073709546503LLU: // 99999998uG'''''''''''''''
	80194	+ {
	80195	+ state.addr = 18446744073709546504LLU; // 99999998uH'''''''''''''''
	80196	+ break;
	80197	+ }
	80198	+ case 18446744073709546504LLU: // 99999998uH'''''''''''''''
	80199	+ {
	80200	+ // ACCUMULATE ARGUMENTS - BEGIN
	80201	+ {
	80202	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
	80203	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80204	+ }
	80205	+ {
	80206	+ uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
	80207	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80208	+ }
	80209	+ {
	80210	+ uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
	80211	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80212	+ }
	80213	+ {
	80214	+ uint64_t arg = /callee_id_/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU);
	80215	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80216	+ }
	80217	+ // ACCUMULATE ARGUMENTS - END
	80218	+ uint64_t return_to = 18446744073709546501LLU;
	80219	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
	80220	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80221	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80222	+ heap.data[0].elem1 = heap.data[0].elem0;
	80223	+ heap.data[0].elem0 = restore;
	80224	+ state.addr = 732615645798520865LLU; // movevarref
	80225	+ break;
	80226	+ }
	80227	+ case 18446744073709546501LLU: // 99999998uE'''''''''''''''
	80228	+ {
	80229	+ state.addr = 18446744073709546502LLU; // 99999998uF'''''''''''''''
	80230	+ break;
	80231	+ }
	80232	+ case 18446744073709546502LLU: // 99999998uF'''''''''''''''
	80233	+ {
	80234	+ // ACCUMULATE ARGUMENTS - BEGIN
	80235	+ {
	80236	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
	80237	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80238	+ }
	80239	+ {
	80240	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 0LLU);
	80241	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80242	+ }
	80243	+ {
	80244	+ uint64_t arg = /typesrc___/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
	80245	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80246	+ }
	80247	+ // ACCUMULATE ARGUMENTS - END
	80248	+ uint64_t return_to = 18446744073709546499LLU;
	80249	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
	80250	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80251	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80252	+ heap.data[0].elem1 = heap.data[0].elem0;
	80253	+ heap.data[0].elem0 = restore;
	80254	+ state.addr = 861504774606556015LLU; // typeassert
	80255	+ break;
	80256	+ }
	80257	+ case 18446744073709546499LLU: // 99999998uC'''''''''''''''
	80258	+ {
	80259	+ state.addr = 18446744073709546500LLU; // 99999998uD'''''''''''''''
	80260	+ break;
	80261	+ }
	80262	+ case 18446744073709546500LLU: // 99999998uD'''''''''''''''
	80263	+ {
	80264	+ fprintf(stdout, "%s", ", &");
	80265	+ // ACCUMULATE ARGUMENTS - BEGIN
	80266	+ {
	80267	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU);
	80268	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80269	+ }
	80270	+ {
	80271	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU);
	80272	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80273	+ }
	80274	+ {
	80275	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU);
	80276	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80277	+ }
	80278	+ {
	80279	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 1LLU);
	80280	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80281	+ }
	80282	+ {
	80283	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 2LLU);
	80284	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80285	+ }
	80286	+ // ACCUMULATE ARGUMENTS - END
	80287	+ uint64_t return_to = 18446744073709546497LLU;
	80288	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
	80289	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80290	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80291	+ heap.data[0].elem1 = heap.data[0].elem0;
	80292	+ heap.data[0].elem0 = restore;
	80293	+ state.addr = 587881357514113024LLU; // emitpar___
	80294	+ break;
	80295	+ }
	80296	+ case 18446744073709546497LLU: // 99999998uA'''''''''''''''
	80297	+ {
	80298	+ state.addr = 18446744073709546498LLU; // 99999998uB'''''''''''''''
	80299	+ break;
	80300	+ }
	80301	+ case 18446744073709546498LLU: // 99999998uB'''''''''''''''
	80302	+ {
	80303	+ fprintf(stdout, "%s", "); // result");
	80304	+ // variable u64 info______ goes out of scope
	80305	+ // emitted destructur for type u64
	80306	+ (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference info______ at 28
	80307	+ // variable u64 idx_______ goes out of scope
	80308	+ // emitted destructur for type u64
	80309	+ (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 27
	80310	+ // variable u64 parameter_ goes out of scope
	80311	+ // emitted destructur for type u64
	80312	+ (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parameter_ at 26
	80313	+ // variable u64 INDIRECT__ goes out of scope
	80314	+ // emitted destructur for type u64
	80315	+ (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 25
	80316	+ // variable u64 mutable___ goes out of scope
	80317	+ // emitted destructur for type u64
	80318	+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 24
	80319	+ // variable u64 init1_____ goes out of scope
	80320	+ // emitted destructur for type u64
	80321	+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference init1_____ at 23
	80322	+ // variable type______ typesrc___ goes out of scope
	80323	+ // emitted destructur for type type______
	80324	+ // ACCUMULATE ARGUMENTS - BEGIN
	80325	+ {
	80326	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	80327	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	80328	+ }
	80329	+ // ACCUMULATE ARGUMENTS - END
	80330	+ uint64_t return_to = 18446744073709546496LLU;
	80331	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	80332	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	80333	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	80334	+ heap.data[0].elem1 = heap.data[0].elem0;
	80335	+ heap.data[0].elem0 = restore;
	80336	+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	80337	+ break;
	80338	+ }
	80339	+ case 18446744073709546496LLU: // 99999998u_'''''''''''''''
	80340	+ {
	80341	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typesrc___ at 22
79904	80342	state.addr = 18446744073709546523LLU; // 99999998u$'''''''''''''''
79905	80343	break;
79906	80344	}
79907	80345	case 18446744073709546523LLU: // 99999998u$'''''''''''''''
79908	80346	{
79909		- ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU)), stdin);
79910		- if(';' != (char)getchar())
79911		- {
79912		- fprintf(stderr, "match failed at char %c\n", (char)59LLU);
79913		- exit(-1);
79914		- }
79915	80347	state.addr = 18446744073709546544LLU; // 99999998uu'''''''''''''''
79916	80348	break;
79917	80349	}

		@@ -79925,7 +80357,7 @@
79925	80357	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
79926	80358	}
79927	80359	// ACCUMULATE ARGUMENTS - END
79928		- uint64_t return_to = 18446744073709546518LLU;
	80360	+ uint64_t return_to = 18446744073709546495LLU;
79929	80361	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
79930	80362	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
79931	80363	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -79934,12 +80366,12 @@
79934	80366	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
79935	80367	break;
79936	80368	}
79937		- case 18446744073709546518LLU: // 99999998uV'''''''''''''''
	80369	+ case 18446744073709546495LLU: // 99999998t9'''''''''''''''
79938	80370	{
79939	80371	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 21
79940	80372	heap.availilable_size_for_dynamic_objects += 0LLU;
79941	80373	heap.availilable_size_for_dynamic_objects += 0LLU;
79942		- state.addr = 18446744073709546517LLU; // 99999998uU'''''''''''''''
	80374	+ state.addr = 18446744073709546494LLU; // 99999998t8'''''''''''''''
79943	80375	break;
79944	80376	}
79945	80377	case 18446744073709546550LLU: // 99999998u0'''''''''''''''

		@@ -79950,7 +80382,7 @@
79950	80382	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
79951	80383	}
79952	80384	// ACCUMULATE ARGUMENTS - END
79953		- uint64_t return_to = 18446744073709546515LLU;
	80385	+ uint64_t return_to = 18446744073709546492LLU;
79954	80386	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
79955	80387	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
79956	80388	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -79959,12 +80391,12 @@
79959	80391	state.addr = 819847183515949359LLU; // reportinit
79960	80392	break;
79961	80393	}
79962		- case 18446744073709546515LLU: // 99999998uS'''''''''''''''
	80394	+ case 18446744073709546492LLU: // 99999998t6'''''''''''''''
79963	80395	{
79964		- state.addr = 18446744073709546516LLU; // 99999998uT'''''''''''''''
	80396	+ state.addr = 18446744073709546493LLU; // 99999998t7'''''''''''''''
79965	80397	break;
79966	80398	}
79967		- case 18446744073709546516LLU: // 99999998uT'''''''''''''''
	80399	+ case 18446744073709546493LLU: // 99999998t7'''''''''''''''
79968	80400	{
79969	80401	fprintf(stderr, "%s", "missing result in assignment from ");
79970	80402	printid(stderr, /callee_id_/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU));

		@@ -79972,10 +80404,10 @@
79972	80404	fprintf(stderr, "%s\n", "");
79973	80405	exit(-1);
79974	80406	}
79975		- state.addr = 18446744073709546517LLU; // 99999998uU'''''''''''''''
	80407	+ state.addr = 18446744073709546494LLU; // 99999998t8'''''''''''''''
79976	80408	break;
79977	80409	}
79978		- case 18446744073709546517LLU: // 99999998uU'''''''''''''''
	80410	+ case 18446744073709546494LLU: // 99999998t8'''''''''''''''
79979	80411	{
79980	80412	state.addr = 18446744073709546552LLU; // 99999998u2'''''''''''''''
79981	80413	break;

		@@ -80061,7 +80493,7 @@
80061	80493	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80062	80494	}
80063	80495	// ACCUMULATE ARGUMENTS - END
80064		- uint64_t return_to = 18446744073709546513LLU;
	80496	+ uint64_t return_to = 18446744073709546490LLU;
80065	80497	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80066	80498	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80067	80499	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80070,12 +80502,12 @@
80070	80502	state.addr = 839519719621918720LLU; // skipws____
80071	80503	break;
80072	80504	}
80073		- case 18446744073709546513LLU: // 99999998uQ'''''''''''''''
	80505	+ case 18446744073709546490LLU: // 99999998t4'''''''''''''''
80074	80506	{
80075		- state.addr = 18446744073709546514LLU; // 99999998uR'''''''''''''''
	80507	+ state.addr = 18446744073709546491LLU; // 99999998t5'''''''''''''''
80076	80508	break;
80077	80509	}
80078		- case 18446744073709546514LLU: // 99999998uR'''''''''''''''
	80510	+ case 18446744073709546491LLU: // 99999998t5'''''''''''''''
80079	80511	{
80080	80512	{
80081	80513	uint64_t arg = 0;

		@@ -80087,21 +80519,21 @@
80087	80519	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
80088	80520	}
80089	80521	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU));
80090		- state.addr = 18446744073709546510LLU; // 99999998uN'''''''''''''''
	80522	+ state.addr = 18446744073709546487LLU; // 99999998t1'''''''''''''''
80091	80523	break;
80092	80524	}
80093		- case 18446744073709546510LLU: // 99999998uN'''''''''''''''
	80525	+ case 18446744073709546487LLU: // 99999998t1'''''''''''''''
80094	80526	{
80095		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546512LLU : 18446744073709546511LLU;
	80527	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546489LLU : 18446744073709546488LLU;
80096	80528	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
80097	80529	break;
80098	80530	}
80099		- case 18446744073709546512LLU: // 99999998uP'''''''''''''''
	80531	+ case 18446744073709546489LLU: // 99999998t3'''''''''''''''
80100	80532	{
80101		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 4LLU)) ? 18446744073709546509LLU : 18446744073709546508LLU;
	80533	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 4LLU)) ? 18446744073709546486LLU : 18446744073709546485LLU;
80102	80534	break;
80103	80535	}
80104		- case 18446744073709546509LLU: // 99999998uM'''''''''''''''
	80536	+ case 18446744073709546486LLU: // 99999998t0'''''''''''''''
80105	80537	{
80106	80538	// ACCUMULATE ARGUMENTS - BEGIN
80107	80539	{

		@@ -80109,7 +80541,7 @@
80109	80541	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80110	80542	}
80111	80543	// ACCUMULATE ARGUMENTS - END
80112		- uint64_t return_to = 18446744073709546506LLU;
	80544	+ uint64_t return_to = 18446744073709546483LLU;
80113	80545	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80114	80546	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80115	80547	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80118,31 +80550,31 @@
80118	80550	state.addr = 819847183515949359LLU; // reportinit
80119	80551	break;
80120	80552	}
80121		- case 18446744073709546506LLU: // 99999998uJ'''''''''''''''
	80553	+ case 18446744073709546483LLU: // 99999998tx'''''''''''''''
80122	80554	{
80123		- state.addr = 18446744073709546507LLU; // 99999998uK'''''''''''''''
	80555	+ state.addr = 18446744073709546484LLU; // 99999998ty'''''''''''''''
80124	80556	break;
80125	80557	}
80126		- case 18446744073709546507LLU: // 99999998uK'''''''''''''''
	80558	+ case 18446744073709546484LLU: // 99999998ty'''''''''''''''
80127	80559	{
80128	80560	{
80129	80561	fprintf(stderr, "%s\n", "can't return c-code in safe environment");
80130	80562	exit(-1);
80131	80563	}
80132		- state.addr = 18446744073709546508LLU; // 99999998uL'''''''''''''''
	80564	+ state.addr = 18446744073709546485LLU; // 99999998tz'''''''''''''''
80133	80565	break;
80134	80566	}
80135		- case 18446744073709546508LLU: // 99999998uL'''''''''''''''
	80567	+ case 18446744073709546485LLU: // 99999998tz'''''''''''''''
80136	80568	{
80137		- state.addr = 18446744073709546505LLU; // 99999998uI'''''''''''''''
	80569	+ state.addr = 18446744073709546482LLU; // 99999998tw'''''''''''''''
80138	80570	break;
80139	80571	}
80140		- case 18446744073709546505LLU: // 99999998uI'''''''''''''''
	80572	+ case 18446744073709546482LLU: // 99999998tw'''''''''''''''
80141	80573	{
80142	80574	access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) = (uint64_t)getchar();
80143	80575	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) > 255)
80144	80576	{
80145		- state.addr = 18446744073709546504LLU; // 99999998uH'''''''''''''''
	80577	+ state.addr = 18446744073709546481LLU; // 99999998tv'''''''''''''''
80146	80578	break;
80147	80579	}
80148	80580	{

		@@ -80150,24 +80582,24 @@
80150	80582	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
80151	80583	}
80152	80584	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU));
80153		- state.addr = 18446744073709546501LLU; // 99999998uE'''''''''''''''
	80585	+ state.addr = 18446744073709546478LLU; // 99999998ts'''''''''''''''
80154	80586	break;
80155	80587	}
80156		- case 18446744073709546501LLU: // 99999998uE'''''''''''''''
	80588	+ case 18446744073709546478LLU: // 99999998ts'''''''''''''''
80157	80589	{
80158		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546503LLU : 18446744073709546502LLU;
	80590	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546480LLU : 18446744073709546479LLU;
80159	80591	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
80160	80592	break;
80161	80593	}
80162		- case 18446744073709546503LLU: // 99999998uG'''''''''''''''
	80594	+ case 18446744073709546480LLU: // 99999998tu'''''''''''''''
80163	80595	{
80164	80596	ungetc(0, stdin);
80165	80597	heap.availilable_size_for_dynamic_objects += 0LLU;
80166	80598	heap.availilable_size_for_dynamic_objects += 0LLU;
80167		- state.addr = 18446744073709546500LLU; // 99999998uD'''''''''''''''
	80599	+ state.addr = 18446744073709546477LLU; // 99999998tr'''''''''''''''
80168	80600	break;
80169	80601	}
80170		- case 18446744073709546502LLU: // 99999998uF'''''''''''''''
	80602	+ case 18446744073709546479LLU: // 99999998tt'''''''''''''''
80171	80603	{
80172	80604	// ACCUMULATE ARGUMENTS - BEGIN
80173	80605	{

		@@ -80175,7 +80607,7 @@
80175	80607	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80176	80608	}
80177	80609	// ACCUMULATE ARGUMENTS - END
80178		- uint64_t return_to = 18446744073709546498LLU;
	80610	+ uint64_t return_to = 18446744073709546475LLU;
80179	80611	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80180	80612	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80181	80613	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80184,46 +80616,46 @@
80184	80616	state.addr = 587881343588366336LLU; // emitccode_
80185	80617	break;
80186	80618	}
80187		- case 18446744073709546498LLU: // 99999998uB'''''''''''''''
	80619	+ case 18446744073709546475LLU: // 99999998tp'''''''''''''''
80188	80620	{
80189		- state.addr = 18446744073709546499LLU; // 99999998uC'''''''''''''''
	80621	+ state.addr = 18446744073709546476LLU; // 99999998tq'''''''''''''''
80190	80622	break;
80191	80623	}
80192		- case 18446744073709546499LLU: // 99999998uC'''''''''''''''
	80624	+ case 18446744073709546476LLU: // 99999998tq'''''''''''''''
80193	80625	{
80194		- state.addr = 18446744073709546500LLU; // 99999998uD'''''''''''''''
	80626	+ state.addr = 18446744073709546477LLU; // 99999998tr'''''''''''''''
80195	80627	break;
80196	80628	}
80197		- case 18446744073709546500LLU: // 99999998uD'''''''''''''''
	80629	+ case 18446744073709546477LLU: // 99999998tr'''''''''''''''
80198	80630	{
80199		- state.addr = 18446744073709546505LLU; // 99999998uI'''''''''''''''
	80631	+ state.addr = 18446744073709546482LLU; // 99999998tw'''''''''''''''
80200	80632	break;
80201	80633	}
80202		- case 18446744073709546504LLU: // 99999998uH'''''''''''''''
	80634	+ case 18446744073709546481LLU: // 99999998tv'''''''''''''''
80203	80635	{
80204	80636
80205		- state.addr = 18446744073709546497LLU; // 99999998uA'''''''''''''''
	80637	+ state.addr = 18446744073709546474LLU; // 99999998to'''''''''''''''
80206	80638	break;
80207	80639	}
80208		- case 18446744073709546497LLU: // 99999998uA'''''''''''''''
	80640	+ case 18446744073709546474LLU: // 99999998to'''''''''''''''
80209	80641	{
80210	80642	access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) = (uint64_t)getchar();
80211		- state.addr = 18446744073709546496LLU; // 99999998u_'''''''''''''''
	80643	+ state.addr = 18446744073709546473LLU; // 99999998tn'''''''''''''''
80212	80644	break;
80213	80645	}
80214		- case 18446744073709546496LLU: // 99999998u_'''''''''''''''
	80646	+ case 18446744073709546473LLU: // 99999998tn'''''''''''''''
80215	80647	{
80216	80648	heap.availilable_size_for_dynamic_objects += 0LLU;
80217	80649	heap.availilable_size_for_dynamic_objects += 0LLU;
80218		- state.addr = 18446744073709546495LLU; // 99999998t9'''''''''''''''
	80650	+ state.addr = 18446744073709546472LLU; // 99999998tm'''''''''''''''
80219	80651	break;
80220	80652	}
80221		- case 18446744073709546511LLU: // 99999998uO'''''''''''''''
	80653	+ case 18446744073709546488LLU: // 99999998t2'''''''''''''''
80222	80654	{
80223		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 10LLU)) ? 18446744073709546494LLU : 18446744073709546493LLU;
	80655	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 10LLU)) ? 18446744073709546471LLU : 18446744073709546470LLU;
80224	80656	break;
80225	80657	}
80226		- case 18446744073709546494LLU: // 99999998t8'''''''''''''''
	80658	+ case 18446744073709546471LLU: // 99999998tl'''''''''''''''
80227	80659	{
80228	80660	{
80229	80661	uint64_t arg = 0;

		@@ -80238,10 +80670,10 @@
80238	80670	uint64_t arg = 0;
80239	80671	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
80240	80672	}
80241		- state.addr = 18446744073709546492LLU; // 99999998t6'''''''''''''''
	80673	+ state.addr = 18446744073709546469LLU; // 99999998tj'''''''''''''''
80242	80674	break;
80243	80675	}
80244		- case 18446744073709546492LLU: // 99999998t6'''''''''''''''
	80676	+ case 18446744073709546469LLU: // 99999998tj'''''''''''''''
80245	80677	{
80246	80678	if(!*LOCAL_ACCESS(heap.data, 20LLU, 18LLU))
80247	80679	{

		@@ -80248,7 +80680,7 @@
80248	80680	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
80249	80681	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
80250	80682	{
80251		- state.addr = 18446744073709546491LLU; // 99999998t5'''''''''''''''
	80683	+ state.addr = 18446744073709546468LLU; // 99999998ti'''''''''''''''
80252	80684	break;
80253	80685	}
80254	80686	}

		@@ -80260,7 +80692,7 @@
80260	80692	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80261	80693	}
80262	80694	// ACCUMULATE ARGUMENTS - END
80263		- uint64_t return_to = 18446744073709546489LLU;
	80695	+ uint64_t return_to = 18446744073709546466LLU;
80264	80696	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80265	80697	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80266	80698	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80269,38 +80701,38 @@
80269	80701	state.addr = 839519719621918720LLU; // skipws____
80270	80702	break;
80271	80703	}
80272		- case 18446744073709546489LLU: // 99999998t3'''''''''''''''
	80704	+ case 18446744073709546466LLU: // 99999998tg'''''''''''''''
80273	80705	{
80274		- state.addr = 18446744073709546490LLU; // 99999998t4'''''''''''''''
	80706	+ state.addr = 18446744073709546467LLU; // 99999998th'''''''''''''''
80275	80707	break;
80276	80708	}
80277		- case 18446744073709546490LLU: // 99999998t4'''''''''''''''
	80709	+ case 18446744073709546467LLU: // 99999998th'''''''''''''''
80278	80710	{
80279		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709546488LLU : 18446744073709546487LLU;
	80711	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709546465LLU : 18446744073709546464LLU;
80280	80712	break;
80281	80713	}
80282		- case 18446744073709546488LLU: // 99999998t2'''''''''''''''
	80714	+ case 18446744073709546465LLU: // 99999998tf'''''''''''''''
80283	80715	{
80284	80716	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
80285	80717
80286		- state.addr = 18446744073709546486LLU; // 99999998t0'''''''''''''''
	80718	+ state.addr = 18446744073709546463LLU; // 99999998td'''''''''''''''
80287	80719	break;
80288	80720	}
80289		- case 18446744073709546486LLU: // 99999998t0'''''''''''''''
	80721	+ case 18446744073709546463LLU: // 99999998td'''''''''''''''
80290	80722	{
80291	80723	*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = 0;
80292	80724	heap.availilable_size_for_dynamic_objects += 0LLU;
80293	80725	heap.availilable_size_for_dynamic_objects += 0LLU;
80294		- state.addr = 18446744073709546485LLU; // 99999998tz'''''''''''''''
	80726	+ state.addr = 18446744073709546462LLU; // 99999998tc'''''''''''''''
80295	80727	break;
80296	80728	}
80297		- case 18446744073709546487LLU: // 99999998t1'''''''''''''''
	80729	+ case 18446744073709546464LLU: // 99999998te'''''''''''''''
80298	80730	{
80299	80731	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
80300		- state.addr = 18446744073709546485LLU; // 99999998tz'''''''''''''''
	80732	+ state.addr = 18446744073709546462LLU; // 99999998tc'''''''''''''''
80301	80733	break;
80302	80734	}
80303		- case 18446744073709546485LLU: // 99999998tz'''''''''''''''
	80735	+ case 18446744073709546462LLU: // 99999998tc'''''''''''''''
80304	80736	{
80305	80737	// ACCUMULATE ARGUMENTS - BEGIN
80306	80738	{

		@@ -80308,7 +80740,7 @@
80308	80740	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80309	80741	}
80310	80742	// ACCUMULATE ARGUMENTS - END
80311		- uint64_t return_to = 18446744073709546483LLU;
	80743	+ uint64_t return_to = 18446744073709546460LLU;
80312	80744	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80313	80745	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80314	80746	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80317,12 +80749,12 @@
80317	80749	state.addr = 839519719621918720LLU; // skipws____
80318	80750	break;
80319	80751	}
80320		- case 18446744073709546483LLU: // 99999998tx'''''''''''''''
	80752	+ case 18446744073709546460LLU: // 99999998ta'''''''''''''''
80321	80753	{
80322		- state.addr = 18446744073709546484LLU; // 99999998ty'''''''''''''''
	80754	+ state.addr = 18446744073709546461LLU; // 99999998tb'''''''''''''''
80323	80755	break;
80324	80756	}
80325		- case 18446744073709546484LLU: // 99999998ty'''''''''''''''
	80757	+ case 18446744073709546461LLU: // 99999998tb'''''''''''''''
80326	80758	{
80327	80759	{
80328	80760	uint64_t arg = 0;

		@@ -80338,7 +80770,7 @@
80338	80770	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80339	80771	}
80340	80772	// ACCUMULATE ARGUMENTS - END
80341		- uint64_t return_to = 18446744073709546479LLU;
	80773	+ uint64_t return_to = 18446744073709546456LLU;
80342	80774	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
80343	80775	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80344	80776	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80347,18 +80779,18 @@
80347	80779	state.addr = 661605045736570880LLU; // isdigit___
80348	80780	break;
80349	80781	}
80350		- case 18446744073709546479LLU: // 99999998tt'''''''''''''''
	80782	+ case 18446744073709546456LLU: // 99999998tX'''''''''''''''
80351	80783	{
80352		- state.addr = 18446744073709546480LLU; // 99999998tu'''''''''''''''
	80784	+ state.addr = 18446744073709546457LLU; // 99999998tY'''''''''''''''
80353	80785	break;
80354	80786	}
80355		- case 18446744073709546480LLU: // 99999998tu'''''''''''''''
	80787	+ case 18446744073709546457LLU: // 99999998tY'''''''''''''''
80356	80788	{
80357		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546482LLU : 18446744073709546481LLU;
	80789	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546459LLU : 18446744073709546458LLU;
80358	80790	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
80359	80791	break;
80360	80792	}
80361		- case 18446744073709546482LLU: // 99999998tw'''''''''''''''
	80793	+ case 18446744073709546459LLU: // 99999998t$'''''''''''''''
80362	80794	{
80363	80795	// ACCUMULATE ARGUMENTS - BEGIN
80364	80796	{

		@@ -80370,7 +80802,7 @@
80370	80802	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80371	80803	}
80372	80804	// ACCUMULATE ARGUMENTS - END
80373		- uint64_t return_to = 18446744073709546477LLU;
	80805	+ uint64_t return_to = 18446744073709546454LLU;
80374	80806	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
80375	80807	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80376	80808	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80379,12 +80811,12 @@
80379	80811	state.addr = 517555565476695680LLU; // assertu64_
80380	80812	break;
80381	80813	}
80382		- case 18446744073709546477LLU: // 99999998tr'''''''''''''''
	80814	+ case 18446744073709546454LLU: // 99999998tV'''''''''''''''
80383	80815	{
80384		- state.addr = 18446744073709546478LLU; // 99999998ts'''''''''''''''
	80816	+ state.addr = 18446744073709546455LLU; // 99999998tW'''''''''''''''
80385	80817	break;
80386	80818	}
80387		- case 18446744073709546478LLU: // 99999998ts'''''''''''''''
	80819	+ case 18446744073709546455LLU: // 99999998tW'''''''''''''''
80388	80820	{
80389	80821	{
80390	80822	uint64_t arg = 0;

		@@ -80391,10 +80823,10 @@
80391	80823	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
80392	80824	}
80393	80825	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
80394		- state.addr = 18446744073709546476LLU; // 99999998tq'''''''''''''''
	80826	+ state.addr = 18446744073709546453LLU; // 99999998tU'''''''''''''''
80395	80827	break;
80396	80828	}
80397		- case 18446744073709546476LLU: // 99999998tq'''''''''''''''
	80829	+ case 18446744073709546453LLU: // 99999998tU'''''''''''''''
80398	80830	{
80399	80831	fprintf(stdout, "%s", "\n ");
80400	80832	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -80419,7 +80851,7 @@
80419	80851	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80420	80852	}
80421	80853	// ACCUMULATE ARGUMENTS - END
80422		- uint64_t return_to = 18446744073709546474LLU;
	80854	+ uint64_t return_to = 18446744073709546451LLU;
80423	80855	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
80424	80856	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80425	80857	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80428,12 +80860,12 @@
80428	80860	state.addr = 587881357514113024LLU; // emitpar___
80429	80861	break;
80430	80862	}
80431		- case 18446744073709546474LLU: // 99999998to'''''''''''''''
	80863	+ case 18446744073709546451LLU: // 99999998tS'''''''''''''''
80432	80864	{
80433		- state.addr = 18446744073709546475LLU; // 99999998tp'''''''''''''''
	80865	+ state.addr = 18446744073709546452LLU; // 99999998tT'''''''''''''''
80434	80866	break;
80435	80867	}
80436		- case 18446744073709546475LLU: // 99999998tp'''''''''''''''
	80868	+ case 18446744073709546452LLU: // 99999998tT'''''''''''''''
80437	80869	{
80438	80870	fprintf(stdout, "%s", " = ");
80439	80871	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -80442,7 +80874,7 @@
80442	80874	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80443	80875	}
80444	80876	// ACCUMULATE ARGUMENTS - END
80445		- uint64_t return_to = 18446744073709546472LLU;
	80877	+ uint64_t return_to = 18446744073709546449LLU;
80446	80878	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80447	80879	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80448	80880	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80451,12 +80883,12 @@
80451	80883	state.addr = 787446708198178816LLU; // printnr___
80452	80884	break;
80453	80885	}
80454		- case 18446744073709546472LLU: // 99999998tm'''''''''''''''
	80886	+ case 18446744073709546449LLU: // 99999998tQ'''''''''''''''
80455	80887	{
80456		- state.addr = 18446744073709546473LLU; // 99999998tn'''''''''''''''
	80888	+ state.addr = 18446744073709546450LLU; // 99999998tR'''''''''''''''
80457	80889	break;
80458	80890	}
80459		- case 18446744073709546473LLU: // 99999998tn'''''''''''''''
	80891	+ case 18446744073709546450LLU: // 99999998tR'''''''''''''''
80460	80892	{
80461	80893	fprintf(stdout, "%s", ";");
80462	80894	// variable u64 n_________ goes out of scope

		@@ -80464,89 +80896,34 @@
80464	80896	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference n_________ at 21
80465	80897	heap.availilable_size_for_dynamic_objects += 0LLU;
80466	80898	heap.availilable_size_for_dynamic_objects += 0LLU;
80467		- state.addr = 18446744073709546471LLU; // 99999998tl'''''''''''''''
	80899	+ state.addr = 18446744073709546448LLU; // 99999998tP'''''''''''''''
80468	80900	break;
80469	80901	}
80470		- case 18446744073709546481LLU: // 99999998tv'''''''''''''''
	80902	+ case 18446744073709546458LLU: // 99999998tZ'''''''''''''''
80471	80903	{
80472	80904	{
80473	80905	uint64_t arg = 0;
80474	80906	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
80475	80907	}
80476		- LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
80477		- state.addr = 18446744073709546470LLU; // 99999998tk'''''''''''''''
80478		- break;
80479		- }
80480		- case 18446744073709546470LLU: // 99999998tk'''''''''''''''
80481		- {
80482	80908	// ACCUMULATE ARGUMENTS - BEGIN
80483	80909	{
80484		- uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU);
	80910	+ uint64_t arg = /newresults/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU);
80485	80911	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80486	80912	}
80487		- // ACCUMULATE ARGUMENTS - END
80488		- uint64_t return_to = 18446744073709546468LLU;
80489		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80490		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80491		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80492		- heap.data[0].elem1 = heap.data[0].elem0;
80493		- heap.data[0].elem0 = restore;
80494		- state.addr = 839519719621918720LLU; // skipws____
80495		- break;
80496		- }
80497		- case 18446744073709546468LLU: // 99999998ti'''''''''''''''
80498		- {
80499		- state.addr = 18446744073709546469LLU; // 99999998tj'''''''''''''''
80500		- break;
80501		- }
80502		- case 18446744073709546469LLU: // 99999998tj'''''''''''''''
80503		- {
80504		-
80505		- state.addr = 18446744073709546467LLU; // 99999998th'''''''''''''''
80506		- break;
80507		- }
80508		- case 18446744073709546467LLU: // 99999998th'''''''''''''''
80509		- {
80510		- *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = 40;
80511		- {
80512		- uint64_t arg = 0;
80513		- LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
80514		- }
80515		- LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /sym_______/LOCAL_ACCESS(heap.data, 22LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
80516		- state.addr = 18446744073709546464LLU; // 99999998te'''''''''''''''
80517		- break;
80518		- }
80519		- case 18446744073709546464LLU: // 99999998te'''''''''''''''
80520		- {
80521		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546466LLU : 18446744073709546465LLU;
80522		- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
80523		- break;
80524		- }
80525		- case 18446744073709546466LLU: // 99999998tg'''''''''''''''
80526		- {
80527		- {
80528		- uint64_t arg = 0;
80529		- LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
80530		- }
80531		- // ACCUMULATE ARGUMENTS - BEGIN
80532	80913	{
80533		- uint64_t arg = /newresults/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
80534		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80535		- }
80536		- {
80537		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 0LLU);
	80914	+ uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 0LLU);
80538	80915	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80539	80916	}
80540	80917	{
80541		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 1LLU);
	80918	+ uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 1LLU);
80542	80919	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80543	80920	}
80544	80921	{
80545		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 2LLU);
	80922	+ uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 2LLU);
80546	80923	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80547	80924	}
80548	80925	// ACCUMULATE ARGUMENTS - END
80549		- uint64_t return_to = 18446744073709546462LLU;
	80926	+ uint64_t return_to = 18446744073709546446LLU;
80550	80927	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
80551	80928	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80552	80929	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80555,13 +80932,17 @@
80555	80932	state.addr = 768289076452424640LLU; // oneresult_
80556	80933	break;
80557	80934	}
80558		- case 18446744073709546462LLU: // 99999998tc'''''''''''''''
	80935	+ case 18446744073709546446LLU: // 99999998tN'''''''''''''''
80559	80936	{
80560		- state.addr = 18446744073709546463LLU; // 99999998td'''''''''''''''
	80937	+ state.addr = 18446744073709546447LLU; // 99999998tO'''''''''''''''
80561	80938	break;
80562	80939	}
80563		- case 18446744073709546463LLU: // 99999998td'''''''''''''''
	80940	+ case 18446744073709546447LLU: // 99999998tO'''''''''''''''
80564	80941	{
	80942	+ {
	80943	+ uint64_t arg = 0;
	80944	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	80945	+ }
80565	80946	// ACCUMULATE ARGUMENTS - BEGIN
80566	80947	{
80567	80948	uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 22LLU, 0LLU);

		@@ -80596,68 +80977,68 @@
80596	80977	LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80597	80978	}
80598	80979	{
80599		- uint64_t arg = /id1_______/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU);
	80980	+ uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 22LLU, 8LLU);
80600	80981	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80601	80982	}
80602	80983	{
80603		- uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 22LLU, 8LLU);
	80984	+ uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 22LLU, 9LLU);
80604	80985	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80605	80986	}
80606	80987	{
80607		- uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 22LLU, 9LLU);
	80988	+ uint64_t arg = /results___/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
80608	80989	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80609	80990	}
80610	80991	{
80611		- uint64_t arg = /newresults/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	80992	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU);
80612	80993	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80613	80994	}
80614	80995	{
80615		- uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU);
	80996	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU);
80616	80997	LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80617	80998	}
80618	80999	{
80619		- uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU);
	81000	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU);
80620	81001	LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80621	81002	}
80622	81003	{
80623		- uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU);
	81004	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU);
80624	81005	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80625	81006	}
80626	81007	{
80627		- uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU);
	81008	+ uint64_t arg = /remainheap/*LOCAL_ACCESS(heap.data, 22LLU, 15LLU);
80628	81009	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80629	81010	}
80630	81011	{
80631		- uint64_t arg = /remainheap/*LOCAL_ACCESS(heap.data, 22LLU, 15LLU);
	81012	+ uint64_t arg = /newresults/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU);
80632	81013	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80633	81014	}
80634	81015	// ACCUMULATE ARGUMENTS - END
80635		- uint64_t return_to = 18446744073709546460LLU;
	81016	+ uint64_t return_to = 18446744073709546444LLU;
80636	81017	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
80637	81018	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80638	81019	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80639	81020	heap.data[0].elem1 = heap.data[0].elem0;
80640	81021	heap.data[0].elem0 = restore;
80641		- state.addr = 782701543315110336LLU; // parsecall_
	81022	+ state.addr = 787472338545441824LLU; // procrvalue
80642	81023	break;
80643	81024	}
80644		- case 18446744073709546460LLU: // 99999998ta'''''''''''''''
	81025	+ case 18446744073709546444LLU: // 99999998tL'''''''''''''''
80645	81026	{
80646		- state.addr = 18446744073709546461LLU; // 99999998tb'''''''''''''''
	81027	+ state.addr = 18446744073709546445LLU; // 99999998tM'''''''''''''''
80647	81028	break;
80648	81029	}
80649		- case 18446744073709546461LLU: // 99999998tb'''''''''''''''
	81030	+ case 18446744073709546445LLU: // 99999998tM'''''''''''''''
80650	81031	{
80651		- // variable list<resdest___> newresults goes out of scope
	81032	+ // variable list<resdest___> results___ goes out of scope
80652	81033	// emitted destructur for type list<resdest___>
80653		- state.addr = 18446744073709546458LLU; // 99999998tZ'''''''''''''''
	81034	+ state.addr = 18446744073709546442LLU; // 99999998tJ'''''''''''''''
80654	81035	break;
80655	81036	}
80656		- case 18446744073709546458LLU: // 99999998tZ'''''''''''''''
	81037	+ case 18446744073709546442LLU: // 99999998tJ'''''''''''''''
80657	81038	{
80658	81039	if(!LOCAL_ACCESS(heap.data, 22LLU, 21LLU)/list*/)
80659	81040	{
80660		- state.addr = 18446744073709546459LLU; // 99999998t$'''''''''''''''
	81041	+ state.addr = 18446744073709546443LLU; // 99999998tK'''''''''''''''
80661	81042	break;
80662	81043	}
80663	81044	// temporary list-element

		@@ -80671,7 +81052,7 @@
80671	81052	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80672	81053	}
80673	81054	// ACCUMULATE ARGUMENTS - END
80674		- uint64_t return_to = 18446744073709546457LLU;
	81055	+ uint64_t return_to = 18446744073709546441LLU;
80675	81056	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80676	81057	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80677	81058	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -80680,26 +81061,31 @@
80680	81061	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
80681	81062	break;
80682	81063	}
80683		- case 18446744073709546457LLU: // 99999998tY'''''''''''''''
	81064	+ case 18446744073709546441LLU: // 99999998tI'''''''''''''''
80684	81065	{
80685	81066	// RELEASE temporary destructor-variable
80686	81067	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
80687		- state.addr = 18446744073709546458LLU; // 99999998tZ'''''''''''''''
	81068	+ state.addr = 18446744073709546442LLU; // 99999998tJ'''''''''''''''
80688	81069	break;
80689	81070	}
80690		- case 18446744073709546459LLU: // 99999998t$'''''''''''''''
	81071	+ case 18446744073709546443LLU: // 99999998tK'''''''''''''''
80691	81072	{
80692		- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 22
80693		- heap.availilable_size_for_dynamic_objects += 0LLU;
80694		- heap.availilable_size_for_dynamic_objects += 0LLU;
80695		- state.addr = 18446744073709546456LLU; // 99999998tX'''''''''''''''
	81073	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 22
	81074	+ // variable list<resdest___> newresults goes out of scope
	81075	+ // emitted destructur for type list<resdest___>
	81076	+ state.addr = 18446744073709546439LLU; // 99999998tG'''''''''''''''
80696	81077	break;
80697	81078	}
80698		- case 18446744073709546465LLU: // 99999998tf'''''''''''''''
	81079	+ case 18446744073709546439LLU: // 99999998tG'''''''''''''''
80699	81080	{
80700		- fprintf(stdout, "%s", "\n swap(&");
	81081	+ if(!LOCAL_ACCESS(heap.data, 21LLU, 20LLU)/list*/)
80701	81082	{
80702		- uint64_t arg = 0;
	81083	+ state.addr = 18446744073709546440LLU; // 99999998tH'''''''''''''''
	81084	+ break;
	81085	+ }
	81086	+ // temporary list-element
	81087	+ {
	81088	+ uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 21LLU, 20LLU)/list*/, 8);
80703	81089	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
80704	81090	}
80705	81091	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -80708,410 +81094,36 @@
80708	81094	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80709	81095	}
80710	81096	// ACCUMULATE ARGUMENTS - END
80711		- uint64_t return_to = 18446744073709546454LLU;
	81097	+ uint64_t return_to = 18446744073709546438LLU;
80712	81098	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
80713	81099	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80714	81100	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80715	81101	heap.data[0].elem1 = heap.data[0].elem0;
80716	81102	heap.data[0].elem0 = restore;
80717		- state.addr = 861504796319285248LLU; // typeu64___
	81103	+ state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
80718	81104	break;
80719	81105	}
80720		- case 18446744073709546454LLU: // 99999998tV'''''''''''''''
	81106	+ case 18446744073709546438LLU: // 99999998tF'''''''''''''''
80721	81107	{
80722		- state.addr = 18446744073709546455LLU; // 99999998tW'''''''''''''''
80723		- break;
80724		- }
80725		- case 18446744073709546455LLU: // 99999998tW'''''''''''''''
80726		- {
80727		- {
80728		- uint64_t arg = 0;
80729		- LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
	81108	+ // RELEASE temporary destructor-variable
	81109	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
	81110	+ state.addr = 18446744073709546439LLU; // 99999998tG'''''''''''''''
	81111	+ break;
80730	81112	}
80731		- *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0;
80732		- {
80733		- uint64_t arg = 0;
80734		- LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/address of current closure/, &arg);
80735		- }
80736		- *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = 0;
80737		- {
80738		- uint64_t arg = 0;
80739		- LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
80740		- }
80741		- *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = 0;
80742		- {
80743		- uint64_t arg = 0;
80744		- LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/address of current closure/, &arg);
80745		- }
80746		- *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = 0;
80747		- {
80748		- uint64_t arg = 0;
80749		- LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
80750		- }
80751		- *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = 0;
80752		- {
80753		- uint64_t arg = 0;
80754		- LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
80755		- }
80756		- *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 0;
80757		- {
80758		- uint64_t arg = 0;
80759		- LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/address of current closure/, &arg);
80760		- }
80761		- *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = 0;
80762		- // ACCUMULATE ARGUMENTS - BEGIN
80763		- {
80764		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU);
80765		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80766		- }
80767		- {
80768		- uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU);
80769		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80770		- }
80771		- {
80772		- uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU);
80773		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80774		- }
80775		- {
80776		- uint64_t arg = /id1_______/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 20LLU);
80777		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80778		- }
80779		- {
80780		- uint64_t arg = /idx_______/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU);
80781		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80782		- }
80783		- {
80784		- uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU);
80785		- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80786		- }
80787		- {
80788		- uint64_t arg = /typesrc___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 21LLU);
80789		- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80790		- }
80791		- {
80792		- uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU);
80793		- LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80794		- }
80795		- {
80796		- uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 25LLU);
80797		- LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80798		- }
80799		- {
80800		- uint64_t arg = /init1_____/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU);
80801		- LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80802		- }
80803		- {
80804		- uint64_t arg = /optelem___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 27LLU);
80805		- LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80806		- }
80807		- {
80808		- uint64_t arg = /consume___/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU);
80809		- LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80810		- }
80811		- // ACCUMULATE ARGUMENTS - END
80812		- uint64_t return_to = 18446744073709546451LLU;
80813		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
80814		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80815		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80816		- heap.data[0].elem1 = heap.data[0].elem0;
80817		- heap.data[0].elem0 = restore;
80818		- state.addr = 604790753280317473LLU; // findvarref
80819		- break;
80820		- }
80821		- case 18446744073709546451LLU: // 99999998tS'''''''''''''''
	81113	+ case 18446744073709546440LLU: // 99999998tH'''''''''''''''
80822	81114	{
80823		- state.addr = 18446744073709546452LLU; // 99999998tT'''''''''''''''
80824		- break;
80825		- }
80826		- case 18446744073709546452LLU: // 99999998tT'''''''''''''''
80827		- {
80828		- // ACCUMULATE ARGUMENTS - BEGIN
80829		- {
80830		- uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU);
80831		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80832		- }
80833		- {
80834		- uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU);
80835		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80836		- }
80837		- {
80838		- uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU);
80839		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80840		- }
80841		- {
80842		- uint64_t arg = /idx_______/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU);
80843		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80844		- }
80845		- {
80846		- uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU);
80847		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80848		- }
80849		- // ACCUMULATE ARGUMENTS - END
80850		- uint64_t return_to = 18446744073709546449LLU;
80851		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
80852		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80853		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80854		- heap.data[0].elem1 = heap.data[0].elem0;
80855		- heap.data[0].elem0 = restore;
80856		- state.addr = 587881357514113024LLU; // emitpar___
80857		- break;
80858		- }
80859		- case 18446744073709546449LLU: // 99999998tQ'''''''''''''''
80860		- {
80861		- state.addr = 18446744073709546450LLU; // 99999998tR'''''''''''''''
80862		- break;
80863		- }
80864		- case 18446744073709546450LLU: // 99999998tR'''''''''''''''
80865		- {
80866		- // variable u64 consume___ goes out of scope
80867		- // emitted destructur for type u64
80868		- (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference consume___ at 29
80869		- // variable u64 optelem___ goes out of scope
80870		- // emitted destructur for type u64
80871		- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 28
80872		- state.addr = 18446744073709546453LLU; // 99999998tU'''''''''''''''
80873		- break;
80874		- }
80875		- case 18446744073709546453LLU: // 99999998tU'''''''''''''''
80876		- {
80877		- // ACCUMULATE ARGUMENTS - BEGIN
80878		- {
80879		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
80880		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80881		- }
80882		- {
80883		- uint64_t arg = /id1_______/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 20LLU);
80884		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80885		- }
80886		- {
80887		- uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU);
80888		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80889		- }
80890		- {
80891		- uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU);
80892		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80893		- }
80894		- {
80895		- uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 25LLU);
80896		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80897		- }
80898		- // ACCUMULATE ARGUMENTS - END
80899		- uint64_t return_to = 18446744073709546447LLU;
80900		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
80901		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80902		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80903		- heap.data[0].elem1 = heap.data[0].elem0;
80904		- heap.data[0].elem0 = restore;
80905		- state.addr = 842862227159939072LLU; // swappable_
80906		- break;
80907		- }
80908		- case 18446744073709546447LLU: // 99999998tO'''''''''''''''
80909		- {
	81115	+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 21
80910	81116	state.addr = 18446744073709546448LLU; // 99999998tP'''''''''''''''
80911	81117	break;
80912	81118	}
80913	81119	case 18446744073709546448LLU: // 99999998tP'''''''''''''''
80914	81120	{
80915		- {
80916		- uint64_t arg = 0;
80917		- LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
80918		- }
80919		- *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 819865187908583424;
80920		- // ACCUMULATE ARGUMENTS - BEGIN
80921		- {
80922		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
80923		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80924		- }
80925		- {
80926		- uint64_t arg = /info______/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU);
80927		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80928		- }
80929		- {
80930		- uint64_t arg = /init1_____/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU);
80931		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80932		- }
80933		- {
80934		- uint64_t arg = /id1_______/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
80935		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80936		- }
80937		- // ACCUMULATE ARGUMENTS - END
80938		- uint64_t return_to = 18446744073709546445LLU;
80939		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
80940		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80941		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80942		- heap.data[0].elem1 = heap.data[0].elem0;
80943		- heap.data[0].elem0 = restore;
80944		- state.addr = 660220410725010287LLU; // initassert
80945		- break;
80946		- }
80947		- case 18446744073709546445LLU: // 99999998tM'''''''''''''''
80948		- {
80949		- state.addr = 18446744073709546446LLU; // 99999998tN'''''''''''''''
80950		- break;
80951		- }
80952		- case 18446744073709546446LLU: // 99999998tN'''''''''''''''
80953		- {
80954		- // ACCUMULATE ARGUMENTS - BEGIN
80955		- {
80956		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
80957		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80958		- }
80959		- {
80960		- uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU);
80961		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80962		- }
80963		- {
80964		- uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU);
80965		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80966		- }
80967		- {
80968		- uint64_t arg = /id1_______/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU);
80969		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80970		- }
80971		- // ACCUMULATE ARGUMENTS - END
80972		- uint64_t return_to = 18446744073709546443LLU;
80973		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
80974		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
80975		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
80976		- heap.data[0].elem1 = heap.data[0].elem0;
80977		- heap.data[0].elem0 = restore;
80978		- state.addr = 732615645798520865LLU; // movevarref
80979		- break;
80980		- }
80981		- case 18446744073709546443LLU: // 99999998tK'''''''''''''''
80982		- {
80983		- state.addr = 18446744073709546444LLU; // 99999998tL'''''''''''''''
80984		- break;
80985		- }
80986		- case 18446744073709546444LLU: // 99999998tL'''''''''''''''
80987		- {
80988		- // ACCUMULATE ARGUMENTS - BEGIN
80989		- {
80990		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU);
80991		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80992		- }
80993		- {
80994		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 0LLU);
80995		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
80996		- }
80997		- {
80998		- uint64_t arg = /typesrc___/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU);
80999		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81000		- }
81001		- // ACCUMULATE ARGUMENTS - END
81002		- uint64_t return_to = 18446744073709546441LLU;
81003		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
81004		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
81005		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
81006		- heap.data[0].elem1 = heap.data[0].elem0;
81007		- heap.data[0].elem0 = restore;
81008		- state.addr = 861504774606556015LLU; // typeassert
81009		- break;
81010		- }
81011		- case 18446744073709546441LLU: // 99999998tI'''''''''''''''
81012		- {
81013		- state.addr = 18446744073709546442LLU; // 99999998tJ'''''''''''''''
81014		- break;
81015		- }
81016		- case 18446744073709546442LLU: // 99999998tJ'''''''''''''''
81017		- {
81018		- fprintf(stdout, "%s", ", &");
81019		- // ACCUMULATE ARGUMENTS - BEGIN
81020		- {
81021		- uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU);
81022		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81023		- }
81024		- {
81025		- uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU);
81026		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81027		- }
81028		- {
81029		- uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU);
81030		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81031		- }
81032		- {
81033		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 1LLU);
81034		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81035		- }
81036		- {
81037		- uint64_t arg = /respar____/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 2LLU);
81038		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81039		- }
81040		- // ACCUMULATE ARGUMENTS - END
81041		- uint64_t return_to = 18446744073709546439LLU;
81042		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
81043		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
81044		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
81045		- heap.data[0].elem1 = heap.data[0].elem0;
81046		- heap.data[0].elem0 = restore;
81047		- state.addr = 587881357514113024LLU; // emitpar___
81048		- break;
81049		- }
81050		- case 18446744073709546439LLU: // 99999998tG'''''''''''''''
81051		- {
81052		- state.addr = 18446744073709546440LLU; // 99999998tH'''''''''''''''
81053		- break;
81054		- }
81055		- case 18446744073709546440LLU: // 99999998tH'''''''''''''''
81056		- {
81057		- fprintf(stdout, "%s", "); // result");
81058		- // variable u64 info______ goes out of scope
81059		- // emitted destructur for type u64
81060		- (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference info______ at 28
81061		- // variable u64 idx_______ goes out of scope
81062		- // emitted destructur for type u64
81063		- (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 27
81064		- // variable u64 parameter_ goes out of scope
81065		- // emitted destructur for type u64
81066		- (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parameter_ at 26
81067		- // variable u64 INDIRECT__ goes out of scope
81068		- // emitted destructur for type u64
81069		- (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 25
81070		- // variable u64 mutable___ goes out of scope
81071		- // emitted destructur for type u64
81072		- (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 24
81073		- // variable u64 init1_____ goes out of scope
81074		- // emitted destructur for type u64
81075		- (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference init1_____ at 23
81076		- // variable type______ typesrc___ goes out of scope
81077		- // emitted destructur for type type______
81078		- // ACCUMULATE ARGUMENTS - BEGIN
81079		- {
81080		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
81081		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
81082		- }
81083		- // ACCUMULATE ARGUMENTS - END
81084		- uint64_t return_to = 18446744073709546438LLU;
81085		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
81086		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
81087		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
81088		- heap.data[0].elem1 = heap.data[0].elem0;
81089		- heap.data[0].elem0 = restore;
81090		- state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
81091		- break;
81092		- }
81093		- case 18446744073709546438LLU: // 99999998tF'''''''''''''''
81094		- {
81095		- (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typesrc___ at 22
81096		- state.addr = 18446744073709546456LLU; // 99999998tX'''''''''''''''
81097		- break;
81098		- }
81099		- case 18446744073709546456LLU: // 99999998tX'''''''''''''''
81100		- {
81101		- // variable u64 id1_______ goes out of scope
81102		- // emitted destructur for type u64
81103		- (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id1_______ at 21
81104		- state.addr = 18446744073709546471LLU; // 99999998tl'''''''''''''''
81105		- break;
81106		- }
81107		- case 18446744073709546471LLU: // 99999998tl'''''''''''''''
81108		- {
81109	81121	// parameter-reference resdest___ respar____ goes out of scope
81110	81122	// parameter-reference list<resdest___> results___ goes out of scope
81111		- state.addr = 18446744073709546492LLU; // 99999998t6'''''''''''''''
	81123	+ state.addr = 18446744073709546469LLU; // 99999998tj'''''''''''''''
81112	81124	break;
81113	81125	}
81114		- case 18446744073709546491LLU: // 99999998t5'''''''''''''''
	81126	+ case 18446744073709546468LLU: // 99999998ti'''''''''''''''
81115	81127	{
81116	81128	// ACCUMULATE ARGUMENTS - BEGIN
81117	81129	{

		@@ -81144,7 +81156,7 @@
81144	81156	state.addr = 18446744073709546435LLU; // 99999998tC'''''''''''''''
81145	81157	break;
81146	81158	}
81147		- case 18446744073709546493LLU: // 99999998t7'''''''''''''''
	81159	+ case 18446744073709546470LLU: // 99999998tk'''''''''''''''
81148	81160	{
81149	81161	// ACCUMULATE ARGUMENTS - BEGIN
81150	81162	{

		@@ -81225,10 +81237,10 @@
81225	81237	}
81226	81238	case 18446744073709546435LLU: // 99999998tC'''''''''''''''
81227	81239	{
81228		- state.addr = 18446744073709546495LLU; // 99999998t9'''''''''''''''
	81240	+ state.addr = 18446744073709546472LLU; // 99999998tm'''''''''''''''
81229	81241	break;
81230	81242	}
81231		- case 18446744073709546495LLU: // 99999998t9'''''''''''''''
	81243	+ case 18446744073709546472LLU: // 99999998tm'''''''''''''''
81232	81244	{
81233	81245	// ACCUMULATE ARGUMENTS - BEGIN
81234	81246	{

		@@ -82933,6 +82945,305 @@
82933	82945	}
82934	82946	break;
82935	82947	}
	82948	+ case 787411865375803879LLU: // prasrtnull
	82949	+ {
	82950	+ // ACCUMULATE ARGUMENTS - BEGIN
	82951	+ {
	82952	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);
	82953	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	82954	+ }
	82955	+ // ACCUMULATE ARGUMENTS - END
	82956	+ uint64_t return_to = 18446744073709546327LLU;
	82957	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	82958	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	82959	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	82960	+ heap.data[0].elem1 = heap.data[0].elem0;
	82961	+ heap.data[0].elem0 = restore;
	82962	+ state.addr = 839519665163075584LLU; // skip______
	82963	+ break;
	82964	+ }
	82965	+ case 18446744073709546327LLU: // 99999998rW'''''''''''''''
	82966	+ {
	82967	+ state.addr = 18446744073709546328LLU; // 99999998rX'''''''''''''''
	82968	+ break;
	82969	+ }
	82970	+ case 18446744073709546328LLU: // 99999998rX'''''''''''''''
	82971	+ {
	82972	+ {
	82973	+ uint64_t arg = 0;
	82974	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	82975	+ }
	82976	+ LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU)));
	82977	+ state.addr = 18446744073709546326LLU; // 99999998rV'''''''''''''''
	82978	+ break;
	82979	+ }
	82980	+ case 18446744073709546326LLU: // 99999998rV'''''''''''''''
	82981	+ {
	82982	+ {
	82983	+ uint64_t arg = 0;
	82984	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	82985	+ }
	82986	+ // ACCUMULATE ARGUMENTS - BEGIN
	82987	+ {
	82988	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	82989	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	82990	+ }
	82991	+ // ACCUMULATE ARGUMENTS - END
	82992	+ uint64_t return_to = 18446744073709546324LLU;
	82993	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	82994	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	82995	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	82996	+ heap.data[0].elem1 = heap.data[0].elem0;
	82997	+ heap.data[0].elem0 = restore;
	82998	+ state.addr = 861504796319285248LLU; // typeu64___
	82999	+ break;
	83000	+ }
	83001	+ case 18446744073709546324LLU: // 99999998rT'''''''''''''''
	83002	+ {
	83003	+ state.addr = 18446744073709546325LLU; // 99999998rU'''''''''''''''
	83004	+ break;
	83005	+ }
	83006	+ case 18446744073709546325LLU: // 99999998rU'''''''''''''''
	83007	+ {
	83008	+ {
	83009	+ uint64_t arg = 0;
	83010	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
	83011	+ }
	83012	+ *LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = 0;
	83013	+ {
	83014	+ uint64_t arg = 0;
	83015	+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
	83016	+ }
	83017	+ *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = 0;
	83018	+ {
	83019	+ uint64_t arg = 0;
	83020	+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
	83021	+ }
	83022	+ *LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = 0;
	83023	+ {
	83024	+ uint64_t arg = 0;
	83025	+ LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
	83026	+ }
	83027	+ *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = 0;
	83028	+ {
	83029	+ uint64_t arg = 0;
	83030	+ LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/address of current closure/, &arg);
	83031	+ }
	83032	+ *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0;
	83033	+ {
	83034	+ uint64_t arg = 0;
	83035	+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/address of current closure/, &arg);
	83036	+ }
	83037	+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 0;
	83038	+ {
	83039	+ uint64_t arg = 0;
	83040	+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
	83041	+ }
	83042	+ *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 0;
	83043	+ // ACCUMULATE ARGUMENTS - BEGIN
	83044	+ {
	83045	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 17LLU, 0LLU);
	83046	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83047	+ }
	83048	+ {
	83049	+ uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 17LLU, 5LLU);
	83050	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83051	+ }
	83052	+ {
	83053	+ uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 17LLU, 6LLU);
	83054	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83055	+ }
	83056	+ {
	83057	+ uint64_t arg = /id________/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 8LLU);
	83058	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83059	+ }
	83060	+ {
	83061	+ uint64_t arg = /dstidx____/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 11LLU);
	83062	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83063	+ }
	83064	+ {
	83065	+ uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 10LLU);
	83066	+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83067	+ }
	83068	+ {
	83069	+ uint64_t arg = /TYPEDST___/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 9LLU);
	83070	+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83071	+ }
	83072	+ {
	83073	+ uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 13LLU);
	83074	+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83075	+ }
	83076	+ {
	83077	+ uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 14LLU);
	83078	+ LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83079	+ }
	83080	+ {
	83081	+ uint64_t arg = /initialize/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 12LLU);
	83082	+ LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83083	+ }
	83084	+ {
	83085	+ uint64_t arg = /optelem___/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 15LLU);
	83086	+ LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83087	+ }
	83088	+ {
	83089	+ uint64_t arg = /consume___/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
	83090	+ LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83091	+ }
	83092	+ // ACCUMULATE ARGUMENTS - END
	83093	+ uint64_t return_to = 18446744073709546321LLU;
	83094	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
	83095	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	83096	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	83097	+ heap.data[0].elem1 = heap.data[0].elem0;
	83098	+ heap.data[0].elem0 = restore;
	83099	+ state.addr = 604790753280317473LLU; // findvarref
	83100	+ break;
	83101	+ }
	83102	+ case 18446744073709546321LLU: // 99999998rQ'''''''''''''''
	83103	+ {
	83104	+ state.addr = 18446744073709546322LLU; // 99999998rR'''''''''''''''
	83105	+ break;
	83106	+ }
	83107	+ case 18446744073709546322LLU: // 99999998rR'''''''''''''''
	83108	+ {
	83109	+ // variable u64 consume___ goes out of scope
	83110	+ // emitted destructur for type u64
	83111	+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference consume___ at 17
	83112	+ // variable u64 optelem___ goes out of scope
	83113	+ // emitted destructur for type u64
	83114	+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 16
	83115	+ state.addr = 18446744073709546323LLU; // 99999998rS'''''''''''''''
	83116	+ break;
	83117	+ }
	83118	+ case 18446744073709546323LLU: // 99999998rS'''''''''''''''
	83119	+ {
	83120	+ state.addr = *LOCAL_ACCESS(heap.data, 15LLU, 12LLU) ? 18446744073709546320LLU : 18446744073709546319LLU;
	83121	+ break;
	83122	+ }
	83123	+ case 18446744073709546320LLU: // 99999998rP'''''''''''''''
	83124	+ {
	83125	+ // ACCUMULATE ARGUMENTS - BEGIN
	83126	+ {
	83127	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 15LLU, 0LLU);
	83128	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83129	+ }
	83130	+ // ACCUMULATE ARGUMENTS - END
	83131	+ uint64_t return_to = 18446744073709546317LLU;
	83132	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	83133	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	83134	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	83135	+ heap.data[0].elem1 = heap.data[0].elem0;
	83136	+ heap.data[0].elem0 = restore;
	83137	+ state.addr = 819847183515949359LLU; // reportinit
	83138	+ break;
	83139	+ }
	83140	+ case 18446744073709546317LLU: // 99999998rM'''''''''''''''
	83141	+ {
	83142	+ state.addr = 18446744073709546318LLU; // 99999998rN'''''''''''''''
	83143	+ break;
	83144	+ }
	83145	+ case 18446744073709546318LLU: // 99999998rN'''''''''''''''
	83146	+ {
	83147	+ fprintf(stderr, "%s", "assert failed: variable ");
	83148	+ // ACCUMULATE ARGUMENTS - BEGIN
	83149	+ {
	83150	+ uint64_t arg = /TYPEDST___/LOCAL_ACCESS_ADDR(heap.data, 15LLU, 9LLU);
	83151	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83152	+ }
	83153	+ // ACCUMULATE ARGUMENTS - END
	83154	+ uint64_t return_to = 18446744073709546315LLU;
	83155	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	83156	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	83157	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	83158	+ heap.data[0].elem1 = heap.data[0].elem0;
	83159	+ heap.data[0].elem0 = restore;
	83160	+ state.addr = 819847183518878432LLU; // reporttype
	83161	+ break;
	83162	+ }
	83163	+ case 18446744073709546315LLU: // 99999998rK'''''''''''''''
	83164	+ {
	83165	+ state.addr = 18446744073709546316LLU; // 99999998rL'''''''''''''''
	83166	+ break;
	83167	+ }
	83168	+ case 18446744073709546316LLU: // 99999998rL'''''''''''''''
	83169	+ {
	83170	+ printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 15LLU, 8LLU));
	83171	+ fprintf(stderr, "%s", " not empty");
	83172	+ {
	83173	+ fprintf(stderr, "%s\n", "");
	83174	+ exit(-1);
	83175	+ }
	83176	+ {
	83177	+ fprintf(stderr, "%s\n", "");
	83178	+ exit(-1);
	83179	+ }
	83180	+ state.addr = 18446744073709546319LLU; // 99999998rO'''''''''''''''
	83181	+ break;
	83182	+ }
	83183	+ case 18446744073709546319LLU: // 99999998rO'''''''''''''''
	83184	+ {
	83185	+ // variable u64 parameter_ goes out of scope
	83186	+ // emitted destructur for type u64
	83187	+ (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parameter_ at 15
	83188	+ // variable u64 mutable___ goes out of scope
	83189	+ // emitted destructur for type u64
	83190	+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 14
	83191	+ // variable u64 initialize goes out of scope
	83192	+ // emitted destructur for type u64
	83193	+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference initialize at 13
	83194	+ // variable u64 dstidx____ goes out of scope
	83195	+ // emitted destructur for type u64
	83196	+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dstidx____ at 12
	83197	+ // variable u64 INDIRECT__ goes out of scope
	83198	+ // emitted destructur for type u64
	83199	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 11
	83200	+ // variable type______ TYPEDST___ goes out of scope
	83201	+ // emitted destructur for type type______
	83202	+ // ACCUMULATE ARGUMENTS - BEGIN
	83203	+ {
	83204	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	83205	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	83206	+ }
	83207	+ // ACCUMULATE ARGUMENTS - END
	83208	+ uint64_t return_to = 18446744073709546314LLU;
	83209	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	83210	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	83211	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	83212	+ heap.data[0].elem1 = heap.data[0].elem0;
	83213	+ heap.data[0].elem0 = restore;
	83214	+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	83215	+ break;
	83216	+ }
	83217	+ case 18446744073709546314LLU: // 99999998rJ'''''''''''''''
	83218	+ {
	83219	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPEDST___ at 10
	83220	+ // variable u64 id________ goes out of scope
	83221	+ // emitted destructur for type u64
	83222	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 9
	83223	+ // parameter-reference u64 c_________ goes out of scope
	83224	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference c_________ at 8
	83225	+ // parameter-reference list<varentry__> varlist___ goes out of scope
	83226	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varlist___ at 7
	83227	+ // parameter-reference list<block_____> blocklist_ goes out of scope
	83228	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference blocklist_ at 6
	83229	+ // parameter-reference list<typedef___> typedefs__ goes out of scope
	83230	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedefs__ at 5
	83231	+ // parameter-reference u64 finite____ goes out of scope
	83232	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference finite____ at 4
	83233	+ // parameter-reference u64 complete__ goes out of scope
	83234	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference complete__ at 3
	83235	+ // parameter-reference u64 tmpaddr___ goes out of scope
	83236	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpaddr___ at 2
	83237	+ // parameter-reference u64 def_id____ goes out of scope
	83238	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference def_id____ at 1
	83239	+ {
	83240	+ uint64_t baseinfo = heap.data[0].elem1;
	83241	+ struct pair pair = unpair(&heap, &baseinfo);
	83242	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	83243	+ state.addr = pair.elem1;
	83244	+ }
	83245	+ break;
	83246	+ }
82936	83247	case 787472320246204585LLU: // procassign
82937	83248	{
82938	83249	{

		@@ -82965,7 +83276,7 @@
82965	83276	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
82966	83277	}
82967	83278	// ACCUMULATE ARGUMENTS - END
82968		- uint64_t return_to = 18446744073709546327LLU;
	83279	+ uint64_t return_to = 18446744073709546312LLU;
82969	83280	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
82970	83281	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
82971	83282	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -82974,12 +83285,12 @@
82974	83285	state.addr = 533581901922699840LLU; // blockopen_
82975	83286	break;
82976	83287	}
82977		- case 18446744073709546327LLU: // 99999998rW'''''''''''''''
	83288	+ case 18446744073709546312LLU: // 99999998rH'''''''''''''''
82978	83289	{
82979		- state.addr = 18446744073709546328LLU; // 99999998rX'''''''''''''''
	83290	+ state.addr = 18446744073709546313LLU; // 99999998rI'''''''''''''''
82980	83291	break;
82981	83292	}
82982		- case 18446744073709546328LLU: // 99999998rX'''''''''''''''
	83293	+ case 18446744073709546313LLU: // 99999998rI'''''''''''''''
82983	83294	{
82984	83295	{
82985	83296	uint64_t arg = 0;

		@@ -83055,7 +83366,7 @@
83055	83366	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83056	83367	}
83057	83368	// ACCUMULATE ARGUMENTS - END
83058		- uint64_t return_to = 18446744073709546325LLU;
	83369	+ uint64_t return_to = 18446744073709546310LLU;
83059	83370	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
83060	83371	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83061	83372	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83064,12 +83375,12 @@
83064	83375	state.addr = 782742327813734400LLU; // pa1_______
83065	83376	break;
83066	83377	}
83067		- case 18446744073709546325LLU: // 99999998rU'''''''''''''''
	83378	+ case 18446744073709546310LLU: // 99999998rF'''''''''''''''
83068	83379	{
83069		- state.addr = 18446744073709546326LLU; // 99999998rV'''''''''''''''
	83380	+ state.addr = 18446744073709546311LLU; // 99999998rG'''''''''''''''
83070	83381	break;
83071	83382	}
83072		- case 18446744073709546326LLU: // 99999998rV'''''''''''''''
	83383	+ case 18446744073709546311LLU: // 99999998rG'''''''''''''''
83073	83384	{
83074	83385	list_reverse(heap.data, &/newresults/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU));
83075	83386	{

		@@ -83133,7 +83444,7 @@
83133	83444	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83134	83445	}
83135	83446	// ACCUMULATE ARGUMENTS - END
83136		- uint64_t return_to = 18446744073709546322LLU;
	83447	+ uint64_t return_to = 18446744073709546307LLU;
83137	83448	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
83138	83449	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83139	83450	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83142,17 +83453,17 @@
83142	83453	state.addr = 533581901720365984LLU; // blockclose
83143	83454	break;
83144	83455	}
83145		- case 18446744073709546322LLU: // 99999998rR'''''''''''''''
	83456	+ case 18446744073709546307LLU: // 99999998rC'''''''''''''''
83146	83457	{
83147		- state.addr = 18446744073709546323LLU; // 99999998rS'''''''''''''''
	83458	+ state.addr = 18446744073709546308LLU; // 99999998rD'''''''''''''''
83148	83459	break;
83149	83460	}
83150		- case 18446744073709546323LLU: // 99999998rS'''''''''''''''
	83461	+ case 18446744073709546308LLU: // 99999998rD'''''''''''''''
83151	83462	{
83152		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 17LLU) ? 18446744073709546321LLU : 18446744073709546320LLU;
	83463	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 17LLU) ? 18446744073709546306LLU : 18446744073709546305LLU;
83153	83464	break;
83154	83465	}
83155		- case 18446744073709546321LLU: // 99999998rQ'''''''''''''''
	83466	+ case 18446744073709546306LLU: // 99999998rB'''''''''''''''
83156	83467	{
83157	83468	fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
83158	83469	{

		@@ -83159,10 +83470,10 @@
83159	83470	fprintf(stderr, "%s\n", "");
83160	83471	exit(-1);
83161	83472	}
83162		- state.addr = 18446744073709546320LLU; // 99999998rP'''''''''''''''
	83473	+ state.addr = 18446744073709546305LLU; // 99999998rA'''''''''''''''
83163	83474	break;
83164	83475	}
83165		- case 18446744073709546320LLU: // 99999998rP'''''''''''''''
	83476	+ case 18446744073709546305LLU: // 99999998rA'''''''''''''''
83166	83477	{
83167	83478	{
83168	83479	uint64_t arg = 0;

		@@ -83169,16 +83480,16 @@
83169	83480	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
83170	83481	}
83171	83482	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 14LLU)) != /ds________/LOCAL_ACCESS(heap.data, 23LLU, 19LLU);
83172		- state.addr = 18446744073709546317LLU; // 99999998rM'''''''''''''''
	83483	+ state.addr = 18446744073709546302LLU; // 99999998q8'''''''''''''''
83173	83484	break;
83174	83485	}
83175		- case 18446744073709546317LLU: // 99999998rM'''''''''''''''
	83486	+ case 18446744073709546302LLU: // 99999998q8'''''''''''''''
83176	83487	{
83177		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546319LLU : 18446744073709546318LLU;
	83488	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546304LLU : 18446744073709546303LLU;
83178	83489	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
83179	83490	break;
83180	83491	}
83181		- case 18446744073709546319LLU: // 99999998rO'''''''''''''''
	83492	+ case 18446744073709546304LLU: // 99999998r_'''''''''''''''
83182	83493	{
83183	83494	fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
83184	83495	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83187,7 +83498,7 @@
83187	83498	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83188	83499	}
83189	83500	// ACCUMULATE ARGUMENTS - END
83190		- uint64_t return_to = 18446744073709546315LLU;
	83501	+ uint64_t return_to = 18446744073709546300LLU;
83191	83502	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83192	83503	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83193	83504	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83196,12 +83507,12 @@
83196	83507	state.addr = 819847183517274112LLU; // reportnr__
83197	83508	break;
83198	83509	}
83199		- case 18446744073709546315LLU: // 99999998rK'''''''''''''''
	83510	+ case 18446744073709546300LLU: // 99999998q6'''''''''''''''
83200	83511	{
83201		- state.addr = 18446744073709546316LLU; // 99999998rL'''''''''''''''
	83512	+ state.addr = 18446744073709546301LLU; // 99999998q7'''''''''''''''
83202	83513	break;
83203	83514	}
83204		- case 18446744073709546316LLU: // 99999998rL'''''''''''''''
	83515	+ case 18446744073709546301LLU: // 99999998q7'''''''''''''''
83205	83516	{
83206	83517	fprintf(stderr, "%s", " != ");
83207	83518	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83210,7 +83521,7 @@
83210	83521	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83211	83522	}
83212	83523	// ACCUMULATE ARGUMENTS - END
83213		- uint64_t return_to = 18446744073709546313LLU;
	83524	+ uint64_t return_to = 18446744073709546298LLU;
83214	83525	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83215	83526	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83216	83527	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83219,21 +83530,21 @@
83219	83530	state.addr = 819847183517274112LLU; // reportnr__
83220	83531	break;
83221	83532	}
83222		- case 18446744073709546313LLU: // 99999998rI'''''''''''''''
	83533	+ case 18446744073709546298LLU: // 99999998q4'''''''''''''''
83223	83534	{
83224		- state.addr = 18446744073709546314LLU; // 99999998rJ'''''''''''''''
	83535	+ state.addr = 18446744073709546299LLU; // 99999998q5'''''''''''''''
83225	83536	break;
83226	83537	}
83227		- case 18446744073709546314LLU: // 99999998rJ'''''''''''''''
	83538	+ case 18446744073709546299LLU: // 99999998q5'''''''''''''''
83228	83539	{
83229	83540	{
83230	83541	fprintf(stderr, "%s\n", "");
83231	83542	exit(-1);
83232	83543	}
83233		- state.addr = 18446744073709546318LLU; // 99999998rN'''''''''''''''
	83544	+ state.addr = 18446744073709546303LLU; // 99999998q9'''''''''''''''
83234	83545	break;
83235	83546	}
83236		- case 18446744073709546318LLU: // 99999998rN'''''''''''''''
	83547	+ case 18446744073709546303LLU: // 99999998q9'''''''''''''''
83237	83548	{
83238	83549	{
83239	83550	uint64_t arg = 0;

		@@ -83240,16 +83551,16 @@
83240	83551	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
83241	83552	}
83242	83553	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 15LLU)) != /rs________/LOCAL_ACCESS(heap.data, 23LLU, 20LLU);
83243		- state.addr = 18446744073709546310LLU; // 99999998rF'''''''''''''''
	83554	+ state.addr = 18446744073709546295LLU; // 99999998q1'''''''''''''''
83244	83555	break;
83245	83556	}
83246		- case 18446744073709546310LLU: // 99999998rF'''''''''''''''
	83557	+ case 18446744073709546295LLU: // 99999998q1'''''''''''''''
83247	83558	{
83248		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546312LLU : 18446744073709546311LLU;
	83559	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546297LLU : 18446744073709546296LLU;
83249	83560	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
83250	83561	break;
83251	83562	}
83252		- case 18446744073709546312LLU: // 99999998rH'''''''''''''''
	83563	+ case 18446744073709546297LLU: // 99999998q3'''''''''''''''
83253	83564	{
83254	83565	fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
83255	83566	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83258,7 +83569,7 @@
83258	83569	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83259	83570	}
83260	83571	// ACCUMULATE ARGUMENTS - END
83261		- uint64_t return_to = 18446744073709546308LLU;
	83572	+ uint64_t return_to = 18446744073709546293LLU;
83262	83573	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83263	83574	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83264	83575	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83267,12 +83578,12 @@
83267	83578	state.addr = 819847183517274112LLU; // reportnr__
83268	83579	break;
83269	83580	}
83270		- case 18446744073709546308LLU: // 99999998rD'''''''''''''''
	83581	+ case 18446744073709546293LLU: // 99999998qz'''''''''''''''
83271	83582	{
83272		- state.addr = 18446744073709546309LLU; // 99999998rE'''''''''''''''
	83583	+ state.addr = 18446744073709546294LLU; // 99999998q0'''''''''''''''
83273	83584	break;
83274	83585	}
83275		- case 18446744073709546309LLU: // 99999998rE'''''''''''''''
	83586	+ case 18446744073709546294LLU: // 99999998q0'''''''''''''''
83276	83587	{
83277	83588	fprintf(stderr, "%s", " != ");
83278	83589	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83281,7 +83592,7 @@
83281	83592	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83282	83593	}
83283	83594	// ACCUMULATE ARGUMENTS - END
83284		- uint64_t return_to = 18446744073709546306LLU;
	83595	+ uint64_t return_to = 18446744073709546291LLU;
83285	83596	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83286	83597	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83287	83598	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83290,21 +83601,21 @@
83290	83601	state.addr = 819847183517274112LLU; // reportnr__
83291	83602	break;
83292	83603	}
83293		- case 18446744073709546306LLU: // 99999998rB'''''''''''''''
	83604	+ case 18446744073709546291LLU: // 99999998qx'''''''''''''''
83294	83605	{
83295		- state.addr = 18446744073709546307LLU; // 99999998rC'''''''''''''''
	83606	+ state.addr = 18446744073709546292LLU; // 99999998qy'''''''''''''''
83296	83607	break;
83297	83608	}
83298		- case 18446744073709546307LLU: // 99999998rC'''''''''''''''
	83609	+ case 18446744073709546292LLU: // 99999998qy'''''''''''''''
83299	83610	{
83300	83611	{
83301	83612	fprintf(stderr, "%s\n", "");
83302	83613	exit(-1);
83303	83614	}
83304		- state.addr = 18446744073709546311LLU; // 99999998rG'''''''''''''''
	83615	+ state.addr = 18446744073709546296LLU; // 99999998q2'''''''''''''''
83305	83616	break;
83306	83617	}
83307		- case 18446744073709546311LLU: // 99999998rG'''''''''''''''
	83618	+ case 18446744073709546296LLU: // 99999998q2'''''''''''''''
83308	83619	{
83309	83620	{
83310	83621	uint64_t arg = 0;

		@@ -83311,16 +83622,16 @@
83311	83622	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
83312	83623	}
83313	83624	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /remainheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 16LLU)) != /rh________/LOCAL_ACCESS(heap.data, 23LLU, 21LLU);
83314		- state.addr = 18446744073709546303LLU; // 99999998q9'''''''''''''''
	83625	+ state.addr = 18446744073709546288LLU; // 99999998qu'''''''''''''''
83315	83626	break;
83316	83627	}
83317		- case 18446744073709546303LLU: // 99999998q9'''''''''''''''
	83628	+ case 18446744073709546288LLU: // 99999998qu'''''''''''''''
83318	83629	{
83319		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546305LLU : 18446744073709546304LLU;
	83630	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546290LLU : 18446744073709546289LLU;
83320	83631	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
83321	83632	break;
83322	83633	}
83323		- case 18446744073709546305LLU: // 99999998rA'''''''''''''''
	83634	+ case 18446744073709546290LLU: // 99999998qw'''''''''''''''
83324	83635	{
83325	83636	fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch ");
83326	83637	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83329,7 +83640,7 @@
83329	83640	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83330	83641	}
83331	83642	// ACCUMULATE ARGUMENTS - END
83332		- uint64_t return_to = 18446744073709546301LLU;
	83643	+ uint64_t return_to = 18446744073709546286LLU;
83333	83644	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83334	83645	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83335	83646	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83338,12 +83649,12 @@
83338	83649	state.addr = 819847183517274112LLU; // reportnr__
83339	83650	break;
83340	83651	}
83341		- case 18446744073709546301LLU: // 99999998q7'''''''''''''''
	83652	+ case 18446744073709546286LLU: // 99999998qs'''''''''''''''
83342	83653	{
83343		- state.addr = 18446744073709546302LLU; // 99999998q8'''''''''''''''
	83654	+ state.addr = 18446744073709546287LLU; // 99999998qt'''''''''''''''
83344	83655	break;
83345	83656	}
83346		- case 18446744073709546302LLU: // 99999998q8'''''''''''''''
	83657	+ case 18446744073709546287LLU: // 99999998qt'''''''''''''''
83347	83658	{
83348	83659	fprintf(stderr, "%s", " != ");
83349	83660	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83352,7 +83663,7 @@
83352	83663	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83353	83664	}
83354	83665	// ACCUMULATE ARGUMENTS - END
83355		- uint64_t return_to = 18446744073709546299LLU;
	83666	+ uint64_t return_to = 18446744073709546284LLU;
83356	83667	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83357	83668	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83358	83669	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83361,21 +83672,21 @@
83361	83672	state.addr = 819847183517274112LLU; // reportnr__
83362	83673	break;
83363	83674	}
83364		- case 18446744073709546299LLU: // 99999998q5'''''''''''''''
	83675	+ case 18446744073709546284LLU: // 99999998qq'''''''''''''''
83365	83676	{
83366		- state.addr = 18446744073709546300LLU; // 99999998q6'''''''''''''''
	83677	+ state.addr = 18446744073709546285LLU; // 99999998qr'''''''''''''''
83367	83678	break;
83368	83679	}
83369		- case 18446744073709546300LLU: // 99999998q6'''''''''''''''
	83680	+ case 18446744073709546285LLU: // 99999998qr'''''''''''''''
83370	83681	{
83371	83682	{
83372	83683	fprintf(stderr, "%s\n", "");
83373	83684	exit(-1);
83374	83685	}
83375		- state.addr = 18446744073709546304LLU; // 99999998r_'''''''''''''''
	83686	+ state.addr = 18446744073709546289LLU; // 99999998qv'''''''''''''''
83376	83687	break;
83377	83688	}
83378		- case 18446744073709546304LLU: // 99999998r_'''''''''''''''
	83689	+ case 18446744073709546289LLU: // 99999998qv'''''''''''''''
83379	83690	{
83380	83691	// variable u64 rh________ goes out of scope
83381	83692	// emitted destructur for type u64

		@@ -83386,10 +83697,10 @@
83386	83697	// variable u64 ds________ goes out of scope
83387	83698	// emitted destructur for type u64
83388	83699	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ds________ at 20
83389		- state.addr = 18446744073709546324LLU; // 99999998rT'''''''''''''''
	83700	+ state.addr = 18446744073709546309LLU; // 99999998rE'''''''''''''''
83390	83701	break;
83391	83702	}
83392		- case 18446744073709546324LLU: // 99999998rT'''''''''''''''
	83703	+ case 18446744073709546309LLU: // 99999998rE'''''''''''''''
83393	83704	{
83394	83705	// ACCUMULATE ARGUMENTS - BEGIN
83395	83706	{

		@@ -83397,7 +83708,7 @@
83397	83708	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83398	83709	}
83399	83710	// ACCUMULATE ARGUMENTS - END
83400		- uint64_t return_to = 18446744073709546297LLU;
	83711	+ uint64_t return_to = 18446744073709546282LLU;
83401	83712	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83402	83713	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83403	83714	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83406,12 +83717,12 @@
83406	83717	state.addr = 839519719621918720LLU; // skipws____
83407	83718	break;
83408	83719	}
83409		- case 18446744073709546297LLU: // 99999998q3'''''''''''''''
	83720	+ case 18446744073709546282LLU: // 99999998qo'''''''''''''''
83410	83721	{
83411		- state.addr = 18446744073709546298LLU; // 99999998q4'''''''''''''''
	83722	+ state.addr = 18446744073709546283LLU; // 99999998qp'''''''''''''''
83412	83723	break;
83413	83724	}
83414		- case 18446744073709546298LLU: // 99999998q4'''''''''''''''
	83725	+ case 18446744073709546283LLU: // 99999998qp'''''''''''''''
83415	83726	{
83416	83727	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 11LLU)));
83417	83728	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83420,7 +83731,7 @@
83420	83731	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83421	83732	}
83422	83733	// ACCUMULATE ARGUMENTS - END
83423		- uint64_t return_to = 18446744073709546295LLU;
	83734	+ uint64_t return_to = 18446744073709546280LLU;
83424	83735	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83425	83736	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83426	83737	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83429,12 +83740,12 @@
83429	83740	state.addr = 839519719621918720LLU; // skipws____
83430	83741	break;
83431	83742	}
83432		- case 18446744073709546295LLU: // 99999998q1'''''''''''''''
	83743	+ case 18446744073709546280LLU: // 99999998qm'''''''''''''''
83433	83744	{
83434		- state.addr = 18446744073709546296LLU; // 99999998q2'''''''''''''''
	83745	+ state.addr = 18446744073709546281LLU; // 99999998qn'''''''''''''''
83435	83746	break;
83436	83747	}
83437		- case 18446744073709546296LLU: // 99999998q2'''''''''''''''
	83748	+ case 18446744073709546281LLU: // 99999998qn'''''''''''''''
83438	83749	{
83439	83750	{
83440	83751	uint64_t arg = 0;

		@@ -83446,16 +83757,16 @@
83446	83757	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
83447	83758	}
83448	83759	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /sym_______/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
83449		- state.addr = 18446744073709546292LLU; // 99999998qy'''''''''''''''
	83760	+ state.addr = 18446744073709546277LLU; // 99999998qj'''''''''''''''
83450	83761	break;
83451	83762	}
83452		- case 18446744073709546292LLU: // 99999998qy'''''''''''''''
	83763	+ case 18446744073709546277LLU: // 99999998qj'''''''''''''''
83453	83764	{
83454		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546294LLU : 18446744073709546293LLU;
	83765	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546279LLU : 18446744073709546278LLU;
83455	83766	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
83456	83767	break;
83457	83768	}
83458		- case 18446744073709546294LLU: // 99999998q0'''''''''''''''
	83769	+ case 18446744073709546279LLU: // 99999998ql'''''''''''''''
83459	83770	{
83460	83771	// ACCUMULATE ARGUMENTS - BEGIN
83461	83772	{

		@@ -83483,7 +83794,7 @@
83483	83794	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83484	83795	}
83485	83796	// ACCUMULATE ARGUMENTS - END
83486		- uint64_t return_to = 18446744073709546290LLU;
	83797	+ uint64_t return_to = 18446744073709546275LLU;
83487	83798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
83488	83799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83489	83800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83492,20 +83803,20 @@
83492	83803	state.addr = 533581901922699840LLU; // blockopen_
83493	83804	break;
83494	83805	}
83495		- case 18446744073709546290LLU: // 99999998qw'''''''''''''''
	83806	+ case 18446744073709546275LLU: // 99999998qh'''''''''''''''
83496	83807	{
83497		- state.addr = 18446744073709546291LLU; // 99999998qx'''''''''''''''
	83808	+ state.addr = 18446744073709546276LLU; // 99999998qi'''''''''''''''
83498	83809	break;
83499	83810	}
83500		- case 18446744073709546291LLU: // 99999998qx'''''''''''''''
	83811	+ case 18446744073709546276LLU: // 99999998qi'''''''''''''''
83501	83812	{
83502	83813	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/newresults/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU));
83503	83814	heap.availilable_size_for_dynamic_objects += 0LLU;
83504	83815	heap.availilable_size_for_dynamic_objects += 0LLU;
83505		- state.addr = 18446744073709546289LLU; // 99999998qv'''''''''''''''
	83816	+ state.addr = 18446744073709546274LLU; // 99999998qg'''''''''''''''
83506	83817	break;
83507	83818	}
83508		- case 18446744073709546293LLU: // 99999998qz'''''''''''''''
	83819	+ case 18446744073709546278LLU: // 99999998qk'''''''''''''''
83509	83820	{
83510	83821	// ACCUMULATE ARGUMENTS - BEGIN
83511	83822	{

		@@ -83577,7 +83888,7 @@
83577	83888	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83578	83889	}
83579	83890	// ACCUMULATE ARGUMENTS - END
83580		- uint64_t return_to = 18446744073709546287LLU;
	83891	+ uint64_t return_to = 18446744073709546272LLU;
83581	83892	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
83582	83893	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83583	83894	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83586,17 +83897,17 @@
83586	83897	state.addr = 787472338545441824LLU; // procrvalue
83587	83898	break;
83588	83899	}
83589		- case 18446744073709546287LLU: // 99999998qt'''''''''''''''
	83900	+ case 18446744073709546272LLU: // 99999998qe'''''''''''''''
83590	83901	{
83591		- state.addr = 18446744073709546288LLU; // 99999998qu'''''''''''''''
	83902	+ state.addr = 18446744073709546273LLU; // 99999998qf'''''''''''''''
83592	83903	break;
83593	83904	}
83594		- case 18446744073709546288LLU: // 99999998qu'''''''''''''''
	83905	+ case 18446744073709546273LLU: // 99999998qf'''''''''''''''
83595	83906	{
83596		- state.addr = 18446744073709546289LLU; // 99999998qv'''''''''''''''
	83907	+ state.addr = 18446744073709546274LLU; // 99999998qg'''''''''''''''
83597	83908	break;
83598	83909	}
83599		- case 18446744073709546289LLU: // 99999998qv'''''''''''''''
	83910	+ case 18446744073709546274LLU: // 99999998qg'''''''''''''''
83600	83911	{
83601	83912	// variable u64 sym_______ goes out of scope
83602	83913	// emitted destructur for type u64

		@@ -83603,14 +83914,14 @@
83603	83914	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 20
83604	83915	// variable list<resdest___> newresults goes out of scope
83605	83916	// emitted destructur for type list<resdest___>
83606		- state.addr = 18446744073709546285LLU; // 99999998qr'''''''''''''''
	83917	+ state.addr = 18446744073709546270LLU; // 99999998qc'''''''''''''''
83607	83918	break;
83608	83919	}
83609		- case 18446744073709546285LLU: // 99999998qr'''''''''''''''
	83920	+ case 18446744073709546270LLU: // 99999998qc'''''''''''''''
83610	83921	{
83611	83922	if(!LOCAL_ACCESS(heap.data, 19LLU, 18LLU)/list*/)
83612	83923	{
83613		- state.addr = 18446744073709546286LLU; // 99999998qs'''''''''''''''
	83924	+ state.addr = 18446744073709546271LLU; // 99999998qd'''''''''''''''
83614	83925	break;
83615	83926	}
83616	83927	// temporary list-element

		@@ -83624,7 +83935,7 @@
83624	83935	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83625	83936	}
83626	83937	// ACCUMULATE ARGUMENTS - END
83627		- uint64_t return_to = 18446744073709546284LLU;
	83938	+ uint64_t return_to = 18446744073709546269LLU;
83628	83939	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83629	83940	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83630	83941	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83633,26 +83944,26 @@
83633	83944	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
83634	83945	break;
83635	83946	}
83636		- case 18446744073709546284LLU: // 99999998qq'''''''''''''''
	83947	+ case 18446744073709546269LLU: // 99999998qb'''''''''''''''
83637	83948	{
83638	83949	// RELEASE temporary destructor-variable
83639	83950	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
83640		- state.addr = 18446744073709546285LLU; // 99999998qr'''''''''''''''
	83951	+ state.addr = 18446744073709546270LLU; // 99999998qc'''''''''''''''
83641	83952	break;
83642	83953	}
83643		- case 18446744073709546286LLU: // 99999998qs'''''''''''''''
	83954	+ case 18446744073709546271LLU: // 99999998qd'''''''''''''''
83644	83955	{
83645	83956	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 19
83646	83957	// variable list<resdest___> tmpresults goes out of scope
83647	83958	// emitted destructur for type list<resdest___>
83648		- state.addr = 18446744073709546282LLU; // 99999998qo'''''''''''''''
	83959	+ state.addr = 18446744073709546267LLU; // 99999998q$'''''''''''''''
83649	83960	break;
83650	83961	}
83651		- case 18446744073709546282LLU: // 99999998qo'''''''''''''''
	83962	+ case 18446744073709546267LLU: // 99999998q$'''''''''''''''
83652	83963	{
83653	83964	if(!LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/list*/)
83654	83965	{
83655		- state.addr = 18446744073709546283LLU; // 99999998qp'''''''''''''''
	83966	+ state.addr = 18446744073709546268LLU; // 99999998qa'''''''''''''''
83656	83967	break;
83657	83968	}
83658	83969	// temporary list-element

		@@ -83666,7 +83977,7 @@
83666	83977	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83667	83978	}
83668	83979	// ACCUMULATE ARGUMENTS - END
83669		- uint64_t return_to = 18446744073709546281LLU;
	83980	+ uint64_t return_to = 18446744073709546266LLU;
83670	83981	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83671	83982	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83672	83983	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83675,14 +83986,14 @@
83675	83986	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
83676	83987	break;
83677	83988	}
83678		- case 18446744073709546281LLU: // 99999998qn'''''''''''''''
	83989	+ case 18446744073709546266LLU: // 99999998qZ'''''''''''''''
83679	83990	{
83680	83991	// RELEASE temporary destructor-variable
83681	83992	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
83682		- state.addr = 18446744073709546282LLU; // 99999998qo'''''''''''''''
	83993	+ state.addr = 18446744073709546267LLU; // 99999998q$'''''''''''''''
83683	83994	break;
83684	83995	}
83685		- case 18446744073709546283LLU: // 99999998qp'''''''''''''''
	83996	+ case 18446744073709546268LLU: // 99999998qa'''''''''''''''
83686	83997	{
83687	83998	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpresults at 18
83688	83999	// parameter-reference u64 remainheap goes out of scope

		@@ -83759,7 +84070,7 @@
83759	84070	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83760	84071	}
83761	84072	// ACCUMULATE ARGUMENTS - END
83762		- uint64_t return_to = 18446744073709546279LLU;
	84073	+ uint64_t return_to = 18446744073709546264LLU;
83763	84074	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
83764	84075	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83765	84076	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83768,12 +84079,12 @@
83768	84079	state.addr = 533581901922699840LLU; // blockopen_
83769	84080	break;
83770	84081	}
83771		- case 18446744073709546279LLU: // 99999998ql'''''''''''''''
	84082	+ case 18446744073709546264LLU: // 99999998qX'''''''''''''''
83772	84083	{
83773		- state.addr = 18446744073709546280LLU; // 99999998qm'''''''''''''''
	84084	+ state.addr = 18446744073709546265LLU; // 99999998qY'''''''''''''''
83774	84085	break;
83775	84086	}
83776		- case 18446744073709546280LLU: // 99999998qm'''''''''''''''
	84087	+ case 18446744073709546265LLU: // 99999998qY'''''''''''''''
83777	84088	{
83778	84089	{
83779	84090	uint64_t arg = 0;

		@@ -83785,7 +84096,7 @@
83785	84096	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83786	84097	}
83787	84098	// ACCUMULATE ARGUMENTS - END
83788		- uint64_t return_to = 18446744073709546277LLU;
	84099	+ uint64_t return_to = 18446744073709546262LLU;
83789	84100	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83790	84101	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83791	84102	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83794,12 +84105,12 @@
83794	84105	state.addr = 839519719621918720LLU; // skipws____
83795	84106	break;
83796	84107	}
83797		- case 18446744073709546277LLU: // 99999998qj'''''''''''''''
	84108	+ case 18446744073709546262LLU: // 99999998qV'''''''''''''''
83798	84109	{
83799		- state.addr = 18446744073709546278LLU; // 99999998qk'''''''''''''''
	84110	+ state.addr = 18446744073709546263LLU; // 99999998qW'''''''''''''''
83800	84111	break;
83801	84112	}
83802		- case 18446744073709546278LLU: // 99999998qk'''''''''''''''
	84113	+ case 18446744073709546263LLU: // 99999998qW'''''''''''''''
83803	84114	{
83804	84115	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)), stdin);
83805	84116	if('(' != (char)getchar())

		@@ -83807,15 +84118,15 @@
83807	84118	fprintf(stderr, "match failed at char %c\n", (char)40LLU);
83808	84119	exit(-1);
83809	84120	}
83810		- state.addr = 18446744073709546276LLU; // 99999998qi'''''''''''''''
	84121	+ state.addr = 18446744073709546261LLU; // 99999998qU'''''''''''''''
83811	84122	break;
83812	84123	}
83813		- case 18446744073709546276LLU: // 99999998qi'''''''''''''''
	84124	+ case 18446744073709546261LLU: // 99999998qU'''''''''''''''
83814	84125	{
83815	84126	access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
83816	84127	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255)
83817	84128	{
83818		- state.addr = 18446744073709546275LLU; // 99999998qh'''''''''''''''
	84129	+ state.addr = 18446744073709546260LLU; // 99999998qT'''''''''''''''
83819	84130	break;
83820	84131	}
83821	84132	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -83824,7 +84135,7 @@
83824	84135	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83825	84136	}
83826	84137	// ACCUMULATE ARGUMENTS - END
83827		- uint64_t return_to = 18446744073709546273LLU;
	84138	+ uint64_t return_to = 18446744073709546258LLU;
83828	84139	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83829	84140	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83830	84141	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83833,12 +84144,12 @@
83833	84144	state.addr = 839519719621918720LLU; // skipws____
83834	84145	break;
83835	84146	}
83836		- case 18446744073709546273LLU: // 99999998qf'''''''''''''''
	84147	+ case 18446744073709546258LLU: // 99999998qR'''''''''''''''
83837	84148	{
83838		- state.addr = 18446744073709546274LLU; // 99999998qg'''''''''''''''
	84149	+ state.addr = 18446744073709546259LLU; // 99999998qS'''''''''''''''
83839	84150	break;
83840	84151	}
83841		- case 18446744073709546274LLU: // 99999998qg'''''''''''''''
	84152	+ case 18446744073709546259LLU: // 99999998qS'''''''''''''''
83842	84153	{
83843	84154	{
83844	84155	uint64_t arg = 0;

		@@ -83855,16 +84166,16 @@
83855	84166	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
83856	84167	}
83857	84168	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /terminator/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) != /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
83858		- state.addr = 18446744073709546270LLU; // 99999998qc'''''''''''''''
	84169	+ state.addr = 18446744073709546255LLU; // 99999998qO'''''''''''''''
83859	84170	break;
83860	84171	}
83861		- case 18446744073709546270LLU: // 99999998qc'''''''''''''''
	84172	+ case 18446744073709546255LLU: // 99999998qO'''''''''''''''
83862	84173	{
83863		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546272LLU : 18446744073709546271LLU;
	84174	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546257LLU : 18446744073709546256LLU;
83864	84175	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
83865	84176	break;
83866	84177	}
83867		- case 18446744073709546272LLU: // 99999998qe'''''''''''''''
	84178	+ case 18446744073709546257LLU: // 99999998qQ'''''''''''''''
83868	84179	{
83869	84180	// ACCUMULATE ARGUMENTS - BEGIN
83870	84181	{

		@@ -83872,7 +84183,7 @@
83872	84183	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83873	84184	}
83874	84185	// ACCUMULATE ARGUMENTS - END
83875		- uint64_t return_to = 18446744073709546267LLU;
	84186	+ uint64_t return_to = 18446744073709546252LLU;
83876	84187	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
83877	84188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83878	84189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83881,12 +84192,12 @@
83881	84192	state.addr = 839519719621918720LLU; // skipws____
83882	84193	break;
83883	84194	}
83884		- case 18446744073709546267LLU: // 99999998q$'''''''''''''''
	84195	+ case 18446744073709546252LLU: // 99999998qL'''''''''''''''
83885	84196	{
83886		- state.addr = 18446744073709546268LLU; // 99999998qa'''''''''''''''
	84197	+ state.addr = 18446744073709546253LLU; // 99999998qM'''''''''''''''
83887	84198	break;
83888	84199	}
83889		- case 18446744073709546268LLU: // 99999998qa'''''''''''''''
	84200	+ case 18446744073709546253LLU: // 99999998qM'''''''''''''''
83890	84201	{
83891	84202	{
83892	84203	uint64_t arg = 0;

		@@ -83893,10 +84204,10 @@
83893	84204	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
83894	84205	}
83895	84206	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
83896		- state.addr = 18446744073709546266LLU; // 99999998qZ'''''''''''''''
	84207	+ state.addr = 18446744073709546251LLU; // 99999998qK'''''''''''''''
83897	84208	break;
83898	84209	}
83899		- case 18446744073709546266LLU: // 99999998qZ'''''''''''''''
	84210	+ case 18446744073709546251LLU: // 99999998qK'''''''''''''''
83900	84211	{
83901	84212	// ACCUMULATE ARGUMENTS - BEGIN
83902	84213	{

		@@ -83968,7 +84279,7 @@
83968	84279	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83969	84280	}
83970	84281	// ACCUMULATE ARGUMENTS - END
83971		- uint64_t return_to = 18446744073709546264LLU;
	84282	+ uint64_t return_to = 18446744073709546249LLU;
83972	84283	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
83973	84284	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
83974	84285	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -83977,20 +84288,20 @@
83977	84288	state.addr = 782742327813734400LLU; // pa1_______
83978	84289	break;
83979	84290	}
83980		- case 18446744073709546264LLU: // 99999998qX'''''''''''''''
	84291	+ case 18446744073709546249LLU: // 99999998qI'''''''''''''''
83981	84292	{
83982		- state.addr = 18446744073709546265LLU; // 99999998qY'''''''''''''''
	84293	+ state.addr = 18446744073709546250LLU; // 99999998qJ'''''''''''''''
83983	84294	break;
83984	84295	}
83985		- case 18446744073709546265LLU: // 99999998qY'''''''''''''''
	84296	+ case 18446744073709546250LLU: // 99999998qJ'''''''''''''''
83986	84297	{
83987	84298	// variable u64 resultid__ goes out of scope
83988	84299	// emitted destructur for type u64
83989	84300	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resultid__ at 21
83990		- state.addr = 18446744073709546269LLU; // 99999998qb'''''''''''''''
	84301	+ state.addr = 18446744073709546254LLU; // 99999998qN'''''''''''''''
83991	84302	break;
83992	84303	}
83993		- case 18446744073709546269LLU: // 99999998qb'''''''''''''''
	84304	+ case 18446744073709546254LLU: // 99999998qN'''''''''''''''
83994	84305	{
83995	84306	// ACCUMULATE ARGUMENTS - BEGIN
83996	84307	{

		@@ -83998,7 +84309,7 @@
83998	84309	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
83999	84310	}
84000	84311	// ACCUMULATE ARGUMENTS - END
84001		- uint64_t return_to = 18446744073709546262LLU;
	84312	+ uint64_t return_to = 18446744073709546247LLU;
84002	84313	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84003	84314	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84004	84315	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84007,12 +84318,12 @@
84007	84318	state.addr = 839519719621918720LLU; // skipws____
84008	84319	break;
84009	84320	}
84010		- case 18446744073709546262LLU: // 99999998qV'''''''''''''''
	84321	+ case 18446744073709546247LLU: // 99999998qG'''''''''''''''
84011	84322	{
84012		- state.addr = 18446744073709546263LLU; // 99999998qW'''''''''''''''
	84323	+ state.addr = 18446744073709546248LLU; // 99999998qH'''''''''''''''
84013	84324	break;
84014	84325	}
84015		- case 18446744073709546263LLU: // 99999998qW'''''''''''''''
	84326	+ case 18446744073709546248LLU: // 99999998qH'''''''''''''''
84016	84327	{
84017	84328	{
84018	84329	uint64_t arg = 0;

		@@ -84019,16 +84330,16 @@
84019	84330	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
84020	84331	}
84021	84332	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /separator_/LOCAL_ACCESS(heap.data, 21LLU, 18LLU) != /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
84022		- state.addr = 18446744073709546259LLU; // 99999998qS'''''''''''''''
	84333	+ state.addr = 18446744073709546244LLU; // 99999998qD'''''''''''''''
84023	84334	break;
84024	84335	}
84025		- case 18446744073709546259LLU: // 99999998qS'''''''''''''''
	84336	+ case 18446744073709546244LLU: // 99999998qD'''''''''''''''
84026	84337	{
84027		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546261LLU : 18446744073709546260LLU;
	84338	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546246LLU : 18446744073709546245LLU;
84028	84339	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
84029	84340	break;
84030	84341	}
84031		- case 18446744073709546261LLU: // 99999998qU'''''''''''''''
	84342	+ case 18446744073709546246LLU: // 99999998qF'''''''''''''''
84032	84343	{
84033	84344	{
84034	84345	uint64_t arg = 0;

		@@ -84035,24 +84346,24 @@
84035	84346	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
84036	84347	}
84037	84348	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /terminator/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
84038		- state.addr = 18446744073709546256LLU; // 99999998qP'''''''''''''''
	84349	+ state.addr = 18446744073709546241LLU; // 99999998qA'''''''''''''''
84039	84350	break;
84040	84351	}
84041		- case 18446744073709546256LLU: // 99999998qP'''''''''''''''
	84352	+ case 18446744073709546241LLU: // 99999998qA'''''''''''''''
84042	84353	{
84043		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546258LLU : 18446744073709546257LLU;
	84354	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546243LLU : 18446744073709546242LLU;
84044	84355	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
84045	84356	break;
84046	84357	}
84047		- case 18446744073709546258LLU: // 99999998qR'''''''''''''''
	84358	+ case 18446744073709546243LLU: // 99999998qC'''''''''''''''
84048	84359	{
84049	84360	ungetc(0, stdin);
84050	84361	heap.availilable_size_for_dynamic_objects += 0LLU;
84051	84362	heap.availilable_size_for_dynamic_objects += 0LLU;
84052		- state.addr = 18446744073709546255LLU; // 99999998qO'''''''''''''''
	84363	+ state.addr = 18446744073709546240LLU; // 99999998q_'''''''''''''''
84053	84364	break;
84054	84365	}
84055		- case 18446744073709546257LLU: // 99999998qQ'''''''''''''''
	84366	+ case 18446744073709546242LLU: // 99999998qB'''''''''''''''
84056	84367	{
84057	84368	// ACCUMULATE ARGUMENTS - BEGIN
84058	84369	{

		@@ -84060,7 +84371,7 @@
84060	84371	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84061	84372	}
84062	84373	// ACCUMULATE ARGUMENTS - END
84063		- uint64_t return_to = 18446744073709546253LLU;
	84374	+ uint64_t return_to = 18446744073709546238LLU;
84064	84375	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84065	84376	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84066	84377	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84069,12 +84380,12 @@
84069	84380	state.addr = 819847183515949359LLU; // reportinit
84070	84381	break;
84071	84382	}
84072		- case 18446744073709546253LLU: // 99999998qM'''''''''''''''
	84383	+ case 18446744073709546238LLU: // 99999998p8'''''''''''''''
84073	84384	{
84074		- state.addr = 18446744073709546254LLU; // 99999998qN'''''''''''''''
	84385	+ state.addr = 18446744073709546239LLU; // 99999998p9'''''''''''''''
84075	84386	break;
84076	84387	}
84077		- case 18446744073709546254LLU: // 99999998qN'''''''''''''''
	84388	+ case 18446744073709546239LLU: // 99999998p9'''''''''''''''
84078	84389	{
84079	84390	fprintf(stderr, "%s", "expected ',' or ')' but found ");
84080	84391	putc((char)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 11LLU)), stderr);

		@@ -84082,28 +84393,28 @@
84082	84393	fprintf(stderr, "%s\n", "");
84083	84394	exit(-1);
84084	84395	}
84085		- state.addr = 18446744073709546255LLU; // 99999998qO'''''''''''''''
	84396	+ state.addr = 18446744073709546240LLU; // 99999998q_'''''''''''''''
84086	84397	break;
84087	84398	}
84088		- case 18446744073709546255LLU: // 99999998qO'''''''''''''''
	84399	+ case 18446744073709546240LLU: // 99999998q_'''''''''''''''
84089	84400	{
84090		- state.addr = 18446744073709546260LLU; // 99999998qT'''''''''''''''
	84401	+ state.addr = 18446744073709546245LLU; // 99999998qE'''''''''''''''
84091	84402	break;
84092	84403	}
84093		- case 18446744073709546260LLU: // 99999998qT'''''''''''''''
	84404	+ case 18446744073709546245LLU: // 99999998qE'''''''''''''''
84094	84405	{
84095	84406	heap.availilable_size_for_dynamic_objects += 0LLU;
84096	84407	heap.availilable_size_for_dynamic_objects += 0LLU;
84097		- state.addr = 18446744073709546252LLU; // 99999998qL'''''''''''''''
	84408	+ state.addr = 18446744073709546237LLU; // 99999998p7'''''''''''''''
84098	84409	break;
84099	84410	}
84100		- case 18446744073709546271LLU: // 99999998qd'''''''''''''''
	84411	+ case 18446744073709546256LLU: // 99999998qP'''''''''''''''
84101	84412	{
84102	84413	ungetc(0, stdin);
84103		- state.addr = 18446744073709546252LLU; // 99999998qL'''''''''''''''
	84414	+ state.addr = 18446744073709546237LLU; // 99999998p7'''''''''''''''
84104	84415	break;
84105	84416	}
84106		- case 18446744073709546252LLU: // 99999998qL'''''''''''''''
	84417	+ case 18446744073709546237LLU: // 99999998p7'''''''''''''''
84107	84418	{
84108	84419	// variable u64 terminator goes out of scope
84109	84420	// emitted destructur for type u64

		@@ -84111,22 +84422,22 @@
84111	84422	// variable u64 separator_ goes out of scope
84112	84423	// emitted destructur for type u64
84113	84424	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference separator_ at 19
84114		- state.addr = 18446744073709546276LLU; // 99999998qi'''''''''''''''
	84425	+ state.addr = 18446744073709546261LLU; // 99999998qU'''''''''''''''
84115	84426	break;
84116	84427	}
84117		- case 18446744073709546275LLU: // 99999998qh'''''''''''''''
	84428	+ case 18446744073709546260LLU: // 99999998qT'''''''''''''''
84118	84429	{
84119	84430
84120		- state.addr = 18446744073709546251LLU; // 99999998qK'''''''''''''''
	84431	+ state.addr = 18446744073709546236LLU; // 99999998p6'''''''''''''''
84121	84432	break;
84122	84433	}
84123		- case 18446744073709546251LLU: // 99999998qK'''''''''''''''
	84434	+ case 18446744073709546236LLU: // 99999998p6'''''''''''''''
84124	84435	{
84125	84436	access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
84126		- state.addr = 18446744073709546250LLU; // 99999998qJ'''''''''''''''
	84437	+ state.addr = 18446744073709546235LLU; // 99999998p5'''''''''''''''
84127	84438	break;
84128	84439	}
84129		- case 18446744073709546250LLU: // 99999998qJ'''''''''''''''
	84440	+ case 18446744073709546235LLU: // 99999998p5'''''''''''''''
84130	84441	{
84131	84442	list_reverse(heap.data, &/newresults/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU));
84132	84443	{

		@@ -84190,7 +84501,7 @@
84190	84501	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84191	84502	}
84192	84503	// ACCUMULATE ARGUMENTS - END
84193		- uint64_t return_to = 18446744073709546247LLU;
	84504	+ uint64_t return_to = 18446744073709546232LLU;
84194	84505	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
84195	84506	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84196	84507	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84199,17 +84510,17 @@
84199	84510	state.addr = 533581901720365984LLU; // blockclose
84200	84511	break;
84201	84512	}
84202		- case 18446744073709546247LLU: // 99999998qG'''''''''''''''
	84513	+ case 18446744073709546232LLU: // 99999998p2'''''''''''''''
84203	84514	{
84204		- state.addr = 18446744073709546248LLU; // 99999998qH'''''''''''''''
	84515	+ state.addr = 18446744073709546233LLU; // 99999998p3'''''''''''''''
84205	84516	break;
84206	84517	}
84207		- case 18446744073709546248LLU: // 99999998qH'''''''''''''''
	84518	+ case 18446744073709546233LLU: // 99999998p3'''''''''''''''
84208	84519	{
84209		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709546246LLU : 18446744073709546245LLU;
	84520	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709546231LLU : 18446744073709546230LLU;
84210	84521	break;
84211	84522	}
84212		- case 18446744073709546246LLU: // 99999998qF'''''''''''''''
	84523	+ case 18446744073709546231LLU: // 99999998p1'''''''''''''''
84213	84524	{
84214	84525	fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
84215	84526	{

		@@ -84216,10 +84527,10 @@
84216	84527	fprintf(stderr, "%s\n", "");
84217	84528	exit(-1);
84218	84529	}
84219		- state.addr = 18446744073709546245LLU; // 99999998qE'''''''''''''''
	84530	+ state.addr = 18446744073709546230LLU; // 99999998p0'''''''''''''''
84220	84531	break;
84221	84532	}
84222		- case 18446744073709546245LLU: // 99999998qE'''''''''''''''
	84533	+ case 18446744073709546230LLU: // 99999998p0'''''''''''''''
84223	84534	{
84224	84535	{
84225	84536	uint64_t arg = 0;

		@@ -84226,16 +84537,16 @@
84226	84537	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
84227	84538	}
84228	84539	LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) != /ds________/LOCAL_ACCESS(heap.data, 22LLU, 18LLU);
84229		- state.addr = 18446744073709546242LLU; // 99999998qB'''''''''''''''
	84540	+ state.addr = 18446744073709546227LLU; // 99999998px'''''''''''''''
84230	84541	break;
84231	84542	}
84232		- case 18446744073709546242LLU: // 99999998qB'''''''''''''''
	84543	+ case 18446744073709546227LLU: // 99999998px'''''''''''''''
84233	84544	{
84234		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546244LLU : 18446744073709546243LLU;
	84545	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546229LLU : 18446744073709546228LLU;
84235	84546	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
84236	84547	break;
84237	84548	}
84238		- case 18446744073709546244LLU: // 99999998qD'''''''''''''''
	84549	+ case 18446744073709546229LLU: // 99999998pz'''''''''''''''
84239	84550	{
84240	84551	fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
84241	84552	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84244,7 +84555,7 @@
84244	84555	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84245	84556	}
84246	84557	// ACCUMULATE ARGUMENTS - END
84247		- uint64_t return_to = 18446744073709546240LLU;
	84558	+ uint64_t return_to = 18446744073709546225LLU;
84248	84559	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84249	84560	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84250	84561	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84253,12 +84564,12 @@
84253	84564	state.addr = 819847183517274112LLU; // reportnr__
84254	84565	break;
84255	84566	}
84256		- case 18446744073709546240LLU: // 99999998q_'''''''''''''''
	84567	+ case 18446744073709546225LLU: // 99999998pv'''''''''''''''
84257	84568	{
84258		- state.addr = 18446744073709546241LLU; // 99999998qA'''''''''''''''
	84569	+ state.addr = 18446744073709546226LLU; // 99999998pw'''''''''''''''
84259	84570	break;
84260	84571	}
84261		- case 18446744073709546241LLU: // 99999998qA'''''''''''''''
	84572	+ case 18446744073709546226LLU: // 99999998pw'''''''''''''''
84262	84573	{
84263	84574	fprintf(stderr, "%s", " != ");
84264	84575	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84267,7 +84578,7 @@
84267	84578	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84268	84579	}
84269	84580	// ACCUMULATE ARGUMENTS - END
84270		- uint64_t return_to = 18446744073709546238LLU;
	84581	+ uint64_t return_to = 18446744073709546223LLU;
84271	84582	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84272	84583	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84273	84584	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84276,21 +84587,21 @@
84276	84587	state.addr = 819847183517274112LLU; // reportnr__
84277	84588	break;
84278	84589	}
84279		- case 18446744073709546238LLU: // 99999998p8'''''''''''''''
	84590	+ case 18446744073709546223LLU: // 99999998pt'''''''''''''''
84280	84591	{
84281		- state.addr = 18446744073709546239LLU; // 99999998p9'''''''''''''''
	84592	+ state.addr = 18446744073709546224LLU; // 99999998pu'''''''''''''''
84282	84593	break;
84283	84594	}
84284		- case 18446744073709546239LLU: // 99999998p9'''''''''''''''
	84595	+ case 18446744073709546224LLU: // 99999998pu'''''''''''''''
84285	84596	{
84286	84597	{
84287	84598	fprintf(stderr, "%s\n", "");
84288	84599	exit(-1);
84289	84600	}
84290		- state.addr = 18446744073709546243LLU; // 99999998qC'''''''''''''''
	84601	+ state.addr = 18446744073709546228LLU; // 99999998py'''''''''''''''
84291	84602	break;
84292	84603	}
84293		- case 18446744073709546243LLU: // 99999998qC'''''''''''''''
	84604	+ case 18446744073709546228LLU: // 99999998py'''''''''''''''
84294	84605	{
84295	84606	{
84296	84607	uint64_t arg = 0;

		@@ -84297,16 +84608,16 @@
84297	84608	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
84298	84609	}
84299	84610	LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 14LLU)) != /rs________/LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
84300		- state.addr = 18446744073709546235LLU; // 99999998p5'''''''''''''''
	84611	+ state.addr = 18446744073709546220LLU; // 99999998pq'''''''''''''''
84301	84612	break;
84302	84613	}
84303		- case 18446744073709546235LLU: // 99999998p5'''''''''''''''
	84614	+ case 18446744073709546220LLU: // 99999998pq'''''''''''''''
84304	84615	{
84305		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546237LLU : 18446744073709546236LLU;
	84616	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546222LLU : 18446744073709546221LLU;
84306	84617	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
84307	84618	break;
84308	84619	}
84309		- case 18446744073709546237LLU: // 99999998p7'''''''''''''''
	84620	+ case 18446744073709546222LLU: // 99999998ps'''''''''''''''
84310	84621	{
84311	84622	fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
84312	84623	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84315,7 +84626,7 @@
84315	84626	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84316	84627	}
84317	84628	// ACCUMULATE ARGUMENTS - END
84318		- uint64_t return_to = 18446744073709546233LLU;
	84629	+ uint64_t return_to = 18446744073709546218LLU;
84319	84630	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84320	84631	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84321	84632	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84324,12 +84635,12 @@
84324	84635	state.addr = 819847183517274112LLU; // reportnr__
84325	84636	break;
84326	84637	}
84327		- case 18446744073709546233LLU: // 99999998p3'''''''''''''''
	84638	+ case 18446744073709546218LLU: // 99999998po'''''''''''''''
84328	84639	{
84329		- state.addr = 18446744073709546234LLU; // 99999998p4'''''''''''''''
	84640	+ state.addr = 18446744073709546219LLU; // 99999998pp'''''''''''''''
84330	84641	break;
84331	84642	}
84332		- case 18446744073709546234LLU: // 99999998p4'''''''''''''''
	84643	+ case 18446744073709546219LLU: // 99999998pp'''''''''''''''
84333	84644	{
84334	84645	fprintf(stderr, "%s", " != ");
84335	84646	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84338,7 +84649,7 @@
84338	84649	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84339	84650	}
84340	84651	// ACCUMULATE ARGUMENTS - END
84341		- uint64_t return_to = 18446744073709546231LLU;
	84652	+ uint64_t return_to = 18446744073709546216LLU;
84342	84653	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84343	84654	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84344	84655	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84347,21 +84658,21 @@
84347	84658	state.addr = 819847183517274112LLU; // reportnr__
84348	84659	break;
84349	84660	}
84350		- case 18446744073709546231LLU: // 99999998p1'''''''''''''''
	84661	+ case 18446744073709546216LLU: // 99999998pm'''''''''''''''
84351	84662	{
84352		- state.addr = 18446744073709546232LLU; // 99999998p2'''''''''''''''
	84663	+ state.addr = 18446744073709546217LLU; // 99999998pn'''''''''''''''
84353	84664	break;
84354	84665	}
84355		- case 18446744073709546232LLU: // 99999998p2'''''''''''''''
	84666	+ case 18446744073709546217LLU: // 99999998pn'''''''''''''''
84356	84667	{
84357	84668	{
84358	84669	fprintf(stderr, "%s\n", "");
84359	84670	exit(-1);
84360	84671	}
84361		- state.addr = 18446744073709546236LLU; // 99999998p6'''''''''''''''
	84672	+ state.addr = 18446744073709546221LLU; // 99999998pr'''''''''''''''
84362	84673	break;
84363	84674	}
84364		- case 18446744073709546236LLU: // 99999998p6'''''''''''''''
	84675	+ case 18446744073709546221LLU: // 99999998pr'''''''''''''''
84365	84676	{
84366	84677	{
84367	84678	uint64_t arg = 0;

		@@ -84368,16 +84679,16 @@
84368	84679	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
84369	84680	}
84370	84681	LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /remainheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 15LLU)) != /rh________/LOCAL_ACCESS(heap.data, 22LLU, 20LLU);
84371		- state.addr = 18446744073709546228LLU; // 99999998py'''''''''''''''
	84682	+ state.addr = 18446744073709546213LLU; // 99999998pj'''''''''''''''
84372	84683	break;
84373	84684	}
84374		- case 18446744073709546228LLU: // 99999998py'''''''''''''''
	84685	+ case 18446744073709546213LLU: // 99999998pj'''''''''''''''
84375	84686	{
84376		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546230LLU : 18446744073709546229LLU;
	84687	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546215LLU : 18446744073709546214LLU;
84377	84688	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
84378	84689	break;
84379	84690	}
84380		- case 18446744073709546230LLU: // 99999998p0'''''''''''''''
	84691	+ case 18446744073709546215LLU: // 99999998pl'''''''''''''''
84381	84692	{
84382	84693	fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch ");
84383	84694	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84386,7 +84697,7 @@
84386	84697	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84387	84698	}
84388	84699	// ACCUMULATE ARGUMENTS - END
84389		- uint64_t return_to = 18446744073709546226LLU;
	84700	+ uint64_t return_to = 18446744073709546211LLU;
84390	84701	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84391	84702	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84392	84703	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84395,12 +84706,12 @@
84395	84706	state.addr = 819847183517274112LLU; // reportnr__
84396	84707	break;
84397	84708	}
84398		- case 18446744073709546226LLU: // 99999998pw'''''''''''''''
	84709	+ case 18446744073709546211LLU: // 99999998ph'''''''''''''''
84399	84710	{
84400		- state.addr = 18446744073709546227LLU; // 99999998px'''''''''''''''
	84711	+ state.addr = 18446744073709546212LLU; // 99999998pi'''''''''''''''
84401	84712	break;
84402	84713	}
84403		- case 18446744073709546227LLU: // 99999998px'''''''''''''''
	84714	+ case 18446744073709546212LLU: // 99999998pi'''''''''''''''
84404	84715	{
84405	84716	fprintf(stderr, "%s", " != ");
84406	84717	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84409,7 +84720,7 @@
84409	84720	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84410	84721	}
84411	84722	// ACCUMULATE ARGUMENTS - END
84412		- uint64_t return_to = 18446744073709546224LLU;
	84723	+ uint64_t return_to = 18446744073709546209LLU;
84413	84724	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84414	84725	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84415	84726	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84418,21 +84729,21 @@
84418	84729	state.addr = 819847183517274112LLU; // reportnr__
84419	84730	break;
84420	84731	}
84421		- case 18446744073709546224LLU: // 99999998pu'''''''''''''''
	84732	+ case 18446744073709546209LLU: // 99999998pf'''''''''''''''
84422	84733	{
84423		- state.addr = 18446744073709546225LLU; // 99999998pv'''''''''''''''
	84734	+ state.addr = 18446744073709546210LLU; // 99999998pg'''''''''''''''
84424	84735	break;
84425	84736	}
84426		- case 18446744073709546225LLU: // 99999998pv'''''''''''''''
	84737	+ case 18446744073709546210LLU: // 99999998pg'''''''''''''''
84427	84738	{
84428	84739	{
84429	84740	fprintf(stderr, "%s\n", "");
84430	84741	exit(-1);
84431	84742	}
84432		- state.addr = 18446744073709546229LLU; // 99999998pz'''''''''''''''
	84743	+ state.addr = 18446744073709546214LLU; // 99999998pk'''''''''''''''
84433	84744	break;
84434	84745	}
84435		- case 18446744073709546229LLU: // 99999998pz'''''''''''''''
	84746	+ case 18446744073709546214LLU: // 99999998pk'''''''''''''''
84436	84747	{
84437	84748	// variable u64 rh________ goes out of scope
84438	84749	// emitted destructur for type u64

		@@ -84443,10 +84754,10 @@
84443	84754	// variable u64 ds________ goes out of scope
84444	84755	// emitted destructur for type u64
84445	84756	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ds________ at 19
84446		- state.addr = 18446744073709546249LLU; // 99999998qI'''''''''''''''
	84757	+ state.addr = 18446744073709546234LLU; // 99999998p4'''''''''''''''
84447	84758	break;
84448	84759	}
84449		- case 18446744073709546249LLU: // 99999998qI'''''''''''''''
	84760	+ case 18446744073709546234LLU: // 99999998p4'''''''''''''''
84450	84761	{
84451	84762	// ACCUMULATE ARGUMENTS - BEGIN
84452	84763	{

		@@ -84454,7 +84765,7 @@
84454	84765	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84455	84766	}
84456	84767	// ACCUMULATE ARGUMENTS - END
84457		- uint64_t return_to = 18446744073709546222LLU;
	84768	+ uint64_t return_to = 18446744073709546207LLU;
84458	84769	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84459	84770	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84460	84771	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84463,12 +84774,12 @@
84463	84774	state.addr = 839519719621918720LLU; // skipws____
84464	84775	break;
84465	84776	}
84466		- case 18446744073709546222LLU: // 99999998ps'''''''''''''''
	84777	+ case 18446744073709546207LLU: // 99999998pd'''''''''''''''
84467	84778	{
84468		- state.addr = 18446744073709546223LLU; // 99999998pt'''''''''''''''
	84779	+ state.addr = 18446744073709546208LLU; // 99999998pe'''''''''''''''
84469	84780	break;
84470	84781	}
84471		- case 18446744073709546223LLU: // 99999998pt'''''''''''''''
	84782	+ case 18446744073709546208LLU: // 99999998pe'''''''''''''''
84472	84783	{
84473	84784	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
84474	84785	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -84477,7 +84788,7 @@
84477	84788	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84478	84789	}
84479	84790	// ACCUMULATE ARGUMENTS - END
84480		- uint64_t return_to = 18446744073709546220LLU;
	84791	+ uint64_t return_to = 18446744073709546205LLU;
84481	84792	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84482	84793	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84483	84794	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84486,12 +84797,12 @@
84486	84797	state.addr = 839519719621918720LLU; // skipws____
84487	84798	break;
84488	84799	}
84489		- case 18446744073709546220LLU: // 99999998pq'''''''''''''''
	84800	+ case 18446744073709546205LLU: // 99999998pb'''''''''''''''
84490	84801	{
84491		- state.addr = 18446744073709546221LLU; // 99999998pr'''''''''''''''
	84802	+ state.addr = 18446744073709546206LLU; // 99999998pc'''''''''''''''
84492	84803	break;
84493	84804	}
84494		- case 18446744073709546221LLU: // 99999998pr'''''''''''''''
	84805	+ case 18446744073709546206LLU: // 99999998pc'''''''''''''''
84495	84806	{
84496	84807	{
84497	84808	uint64_t arg = 0;

		@@ -84503,16 +84814,16 @@
84503	84814	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
84504	84815	}
84505	84816	LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /sym_______/LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 11LLU));
84506		- state.addr = 18446744073709546217LLU; // 99999998pn'''''''''''''''
	84817	+ state.addr = 18446744073709546202LLU; // 99999998pZ'''''''''''''''
84507	84818	break;
84508	84819	}
84509		- case 18446744073709546217LLU: // 99999998pn'''''''''''''''
	84820	+ case 18446744073709546202LLU: // 99999998pZ'''''''''''''''
84510	84821	{
84511		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546219LLU : 18446744073709546218LLU;
	84822	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546204LLU : 18446744073709546203LLU;
84512	84823	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
84513	84824	break;
84514	84825	}
84515		- case 18446744073709546219LLU: // 99999998pp'''''''''''''''
	84826	+ case 18446744073709546204LLU: // 99999998pa'''''''''''''''
84516	84827	{
84517	84828	// ACCUMULATE ARGUMENTS - BEGIN
84518	84829	{

		@@ -84540,7 +84851,7 @@
84540	84851	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84541	84852	}
84542	84853	// ACCUMULATE ARGUMENTS - END
84543		- uint64_t return_to = 18446744073709546215LLU;
	84854	+ uint64_t return_to = 18446744073709546200LLU;
84544	84855	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
84545	84856	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84546	84857	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84549,20 +84860,20 @@
84549	84860	state.addr = 533581901922699840LLU; // blockopen_
84550	84861	break;
84551	84862	}
84552		- case 18446744073709546215LLU: // 99999998pl'''''''''''''''
	84863	+ case 18446744073709546200LLU: // 99999998pX'''''''''''''''
84553	84864	{
84554		- state.addr = 18446744073709546216LLU; // 99999998pm'''''''''''''''
	84865	+ state.addr = 18446744073709546201LLU; // 99999998pY'''''''''''''''
84555	84866	break;
84556	84867	}
84557		- case 18446744073709546216LLU: // 99999998pm'''''''''''''''
	84868	+ case 18446744073709546201LLU: // 99999998pY'''''''''''''''
84558	84869	{
84559	84870	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 10LLU)), &/newresults/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU));
84560	84871	heap.availilable_size_for_dynamic_objects += 0LLU;
84561	84872	heap.availilable_size_for_dynamic_objects += 0LLU;
84562		- state.addr = 18446744073709546214LLU; // 99999998pk'''''''''''''''
	84873	+ state.addr = 18446744073709546199LLU; // 99999998pW'''''''''''''''
84563	84874	break;
84564	84875	}
84565		- case 18446744073709546218LLU: // 99999998po'''''''''''''''
	84876	+ case 18446744073709546203LLU: // 99999998p$'''''''''''''''
84566	84877	{
84567	84878	// ACCUMULATE ARGUMENTS - BEGIN
84568	84879	{

		@@ -84634,7 +84945,7 @@
84634	84945	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84635	84946	}
84636	84947	// ACCUMULATE ARGUMENTS - END
84637		- uint64_t return_to = 18446744073709546212LLU;
	84948	+ uint64_t return_to = 18446744073709546197LLU;
84638	84949	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
84639	84950	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84640	84951	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84643,17 +84954,17 @@
84643	84954	state.addr = 787472338545441824LLU; // procrvalue
84644	84955	break;
84645	84956	}
84646		- case 18446744073709546212LLU: // 99999998pi'''''''''''''''
	84957	+ case 18446744073709546197LLU: // 99999998pU'''''''''''''''
84647	84958	{
84648		- state.addr = 18446744073709546213LLU; // 99999998pj'''''''''''''''
	84959	+ state.addr = 18446744073709546198LLU; // 99999998pV'''''''''''''''
84649	84960	break;
84650	84961	}
84651		- case 18446744073709546213LLU: // 99999998pj'''''''''''''''
	84962	+ case 18446744073709546198LLU: // 99999998pV'''''''''''''''
84652	84963	{
84653		- state.addr = 18446744073709546214LLU; // 99999998pk'''''''''''''''
	84964	+ state.addr = 18446744073709546199LLU; // 99999998pW'''''''''''''''
84654	84965	break;
84655	84966	}
84656		- case 18446744073709546214LLU: // 99999998pk'''''''''''''''
	84967	+ case 18446744073709546199LLU: // 99999998pW'''''''''''''''
84657	84968	{
84658	84969	// variable u64 sym_______ goes out of scope
84659	84970	// emitted destructur for type u64

		@@ -84660,14 +84971,14 @@
84660	84971	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 19
84661	84972	// variable list<resdest___> newresults goes out of scope
84662	84973	// emitted destructur for type list<resdest___>
84663		- state.addr = 18446744073709546210LLU; // 99999998pg'''''''''''''''
	84974	+ state.addr = 18446744073709546195LLU; // 99999998pS'''''''''''''''
84664	84975	break;
84665	84976	}
84666		- case 18446744073709546210LLU: // 99999998pg'''''''''''''''
	84977	+ case 18446744073709546195LLU: // 99999998pS'''''''''''''''
84667	84978	{
84668	84979	if(!LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/list*/)
84669	84980	{
84670		- state.addr = 18446744073709546211LLU; // 99999998ph'''''''''''''''
	84981	+ state.addr = 18446744073709546196LLU; // 99999998pT'''''''''''''''
84671	84982	break;
84672	84983	}
84673	84984	// temporary list-element

		@@ -84681,7 +84992,7 @@
84681	84992	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84682	84993	}
84683	84994	// ACCUMULATE ARGUMENTS - END
84684		- uint64_t return_to = 18446744073709546209LLU;
	84995	+ uint64_t return_to = 18446744073709546194LLU;
84685	84996	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84686	84997	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84687	84998	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84690,26 +85001,26 @@
84690	85001	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
84691	85002	break;
84692	85003	}
84693		- case 18446744073709546209LLU: // 99999998pf'''''''''''''''
	85004	+ case 18446744073709546194LLU: // 99999998pR'''''''''''''''
84694	85005	{
84695	85006	// RELEASE temporary destructor-variable
84696	85007	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
84697		- state.addr = 18446744073709546210LLU; // 99999998pg'''''''''''''''
	85008	+ state.addr = 18446744073709546195LLU; // 99999998pS'''''''''''''''
84698	85009	break;
84699	85010	}
84700		- case 18446744073709546211LLU: // 99999998ph'''''''''''''''
	85011	+ case 18446744073709546196LLU: // 99999998pT'''''''''''''''
84701	85012	{
84702	85013	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 18
84703	85014	// variable list<resdest___> tmpresults goes out of scope
84704	85015	// emitted destructur for type list<resdest___>
84705		- state.addr = 18446744073709546207LLU; // 99999998pd'''''''''''''''
	85016	+ state.addr = 18446744073709546192LLU; // 99999998pP'''''''''''''''
84706	85017	break;
84707	85018	}
84708		- case 18446744073709546207LLU: // 99999998pd'''''''''''''''
	85019	+ case 18446744073709546192LLU: // 99999998pP'''''''''''''''
84709	85020	{
84710	85021	if(!LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/list*/)
84711	85022	{
84712		- state.addr = 18446744073709546208LLU; // 99999998pe'''''''''''''''
	85023	+ state.addr = 18446744073709546193LLU; // 99999998pQ'''''''''''''''
84713	85024	break;
84714	85025	}
84715	85026	// temporary list-element

		@@ -84723,7 +85034,7 @@
84723	85034	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84724	85035	}
84725	85036	// ACCUMULATE ARGUMENTS - END
84726		- uint64_t return_to = 18446744073709546206LLU;
	85037	+ uint64_t return_to = 18446744073709546191LLU;
84727	85038	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84728	85039	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84729	85040	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84732,14 +85043,14 @@
84732	85043	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
84733	85044	break;
84734	85045	}
84735		- case 18446744073709546206LLU: // 99999998pc'''''''''''''''
	85046	+ case 18446744073709546191LLU: // 99999998pO'''''''''''''''
84736	85047	{
84737	85048	// RELEASE temporary destructor-variable
84738	85049	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
84739		- state.addr = 18446744073709546207LLU; // 99999998pd'''''''''''''''
	85050	+ state.addr = 18446744073709546192LLU; // 99999998pP'''''''''''''''
84740	85051	break;
84741	85052	}
84742		- case 18446744073709546208LLU: // 99999998pe'''''''''''''''
	85053	+ case 18446744073709546193LLU: // 99999998pQ'''''''''''''''
84743	85054	{
84744	85055	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpresults at 17
84745	85056	// parameter-reference u64 remainheap goes out of scope

		@@ -84790,7 +85101,7 @@
84790	85101	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84791	85102	}
84792	85103	// ACCUMULATE ARGUMENTS - END
84793		- uint64_t return_to = 18446744073709546204LLU;
	85104	+ uint64_t return_to = 18446744073709546189LLU;
84794	85105	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84795	85106	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84796	85107	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84799,12 +85110,12 @@
84799	85110	state.addr = 839519719621918720LLU; // skipws____
84800	85111	break;
84801	85112	}
84802		- case 18446744073709546204LLU: // 99999998pa'''''''''''''''
	85113	+ case 18446744073709546189LLU: // 99999998pM'''''''''''''''
84803	85114	{
84804		- state.addr = 18446744073709546205LLU; // 99999998pb'''''''''''''''
	85115	+ state.addr = 18446744073709546190LLU; // 99999998pN'''''''''''''''
84805	85116	break;
84806	85117	}
84807		- case 18446744073709546205LLU: // 99999998pb'''''''''''''''
	85118	+ case 18446744073709546190LLU: // 99999998pN'''''''''''''''
84808	85119	{
84809	85120	{
84810	85121	uint64_t arg = 0;

		@@ -84811,10 +85122,10 @@
84811	85122	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
84812	85123	}
84813	85124	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU)));
84814		- state.addr = 18446744073709546203LLU; // 99999998p$'''''''''''''''
	85125	+ state.addr = 18446744073709546188LLU; // 99999998pL'''''''''''''''
84815	85126	break;
84816	85127	}
84817		- case 18446744073709546203LLU: // 99999998p$'''''''''''''''
	85128	+ case 18446744073709546188LLU: // 99999998pL'''''''''''''''
84818	85129	{
84819	85130	{
84820	85131	uint64_t arg = 0;

		@@ -84843,7 +85154,7 @@
84843	85154	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84844	85155	}
84845	85156	// ACCUMULATE ARGUMENTS - END
84846		- uint64_t return_to = 18446744073709546201LLU;
	85157	+ uint64_t return_to = 18446744073709546186LLU;
84847	85158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
84848	85159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84849	85160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84852,12 +85163,12 @@
84852	85163	state.addr = 782701543487916768LLU; // parsemtype
84853	85164	break;
84854	85165	}
84855		- case 18446744073709546201LLU: // 99999998pY'''''''''''''''
	85166	+ case 18446744073709546186LLU: // 99999998pJ'''''''''''''''
84856	85167	{
84857		- state.addr = 18446744073709546202LLU; // 99999998pZ'''''''''''''''
	85168	+ state.addr = 18446744073709546187LLU; // 99999998pK'''''''''''''''
84858	85169	break;
84859	85170	}
84860		- case 18446744073709546202LLU: // 99999998pZ'''''''''''''''
	85171	+ case 18446744073709546187LLU: // 99999998pK'''''''''''''''
84861	85172	{
84862	85173	// ACCUMULATE ARGUMENTS - BEGIN
84863	85174	{

		@@ -84865,7 +85176,7 @@
84865	85176	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84866	85177	}
84867	85178	// ACCUMULATE ARGUMENTS - END
84868		- uint64_t return_to = 18446744073709546199LLU;
	85179	+ uint64_t return_to = 18446744073709546184LLU;
84869	85180	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84870	85181	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84871	85182	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84874,24 +85185,24 @@
84874	85185	state.addr = 839519719621918720LLU; // skipws____
84875	85186	break;
84876	85187	}
84877		- case 18446744073709546199LLU: // 99999998pW'''''''''''''''
	85188	+ case 18446744073709546184LLU: // 99999998pH'''''''''''''''
84878	85189	{
84879		- state.addr = 18446744073709546200LLU; // 99999998pX'''''''''''''''
	85190	+ state.addr = 18446744073709546185LLU; // 99999998pI'''''''''''''''
84880	85191	break;
84881	85192	}
84882		- case 18446744073709546200LLU: // 99999998pX'''''''''''''''
	85193	+ case 18446744073709546185LLU: // 99999998pI'''''''''''''''
84883	85194	{
84884	85195
84885		- state.addr = 18446744073709546198LLU; // 99999998pV'''''''''''''''
	85196	+ state.addr = 18446744073709546183LLU; // 99999998pG'''''''''''''''
84886	85197	break;
84887	85198	}
84888		- case 18446744073709546198LLU: // 99999998pV'''''''''''''''
	85199	+ case 18446744073709546183LLU: // 99999998pG'''''''''''''''
84889	85200	{
84890	85201	LOCAL_ACCESS(heap.data, 19LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
84891		- state.addr = 18446744073709546197LLU; // 99999998pU'''''''''''''''
	85202	+ state.addr = 18446744073709546182LLU; // 99999998pF'''''''''''''''
84892	85203	break;
84893	85204	}
84894		- case 18446744073709546197LLU: // 99999998pU'''''''''''''''
	85205	+ case 18446744073709546182LLU: // 99999998pF'''''''''''''''
84895	85206	{
84896	85207	{
84897	85208	uint64_t arg = 0;

		@@ -84916,7 +85227,7 @@
84916	85227	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84917	85228	}
84918	85229	// ACCUMULATE ARGUMENTS - END
84919		- uint64_t return_to = 18446744073709546195LLU;
	85230	+ uint64_t return_to = 18446744073709546180LLU;
84920	85231	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
84921	85232	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84922	85233	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84925,17 +85236,17 @@
84925	85236	state.addr = 696275824427849761LLU; // knowvarref
84926	85237	break;
84927	85238	}
84928		- case 18446744073709546195LLU: // 99999998pS'''''''''''''''
	85239	+ case 18446744073709546180LLU: // 99999998pD'''''''''''''''
84929	85240	{
84930		- state.addr = 18446744073709546196LLU; // 99999998pT'''''''''''''''
	85241	+ state.addr = 18446744073709546181LLU; // 99999998pE'''''''''''''''
84931	85242	break;
84932	85243	}
84933		- case 18446744073709546196LLU: // 99999998pT'''''''''''''''
	85244	+ case 18446744073709546181LLU: // 99999998pE'''''''''''''''
84934	85245	{
84935		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546194LLU : 18446744073709546193LLU;
	85246	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546179LLU : 18446744073709546178LLU;
84936	85247	break;
84937	85248	}
84938		- case 18446744073709546194LLU: // 99999998pR'''''''''''''''
	85249	+ case 18446744073709546179LLU: // 99999998pC'''''''''''''''
84939	85250	{
84940	85251	// ACCUMULATE ARGUMENTS - BEGIN
84941	85252	{

		@@ -84943,7 +85254,7 @@
84943	85254	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
84944	85255	}
84945	85256	// ACCUMULATE ARGUMENTS - END
84946		- uint64_t return_to = 18446744073709546191LLU;
	85257	+ uint64_t return_to = 18446744073709546176LLU;
84947	85258	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
84948	85259	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
84949	85260	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -84952,12 +85263,12 @@
84952	85263	state.addr = 839519719621918720LLU; // skipws____
84953	85264	break;
84954	85265	}
84955		- case 18446744073709546191LLU: // 99999998pO'''''''''''''''
	85266	+ case 18446744073709546176LLU: // 99999998p_'''''''''''''''
84956	85267	{
84957		- state.addr = 18446744073709546192LLU; // 99999998pP'''''''''''''''
	85268	+ state.addr = 18446744073709546177LLU; // 99999998pA'''''''''''''''
84958	85269	break;
84959	85270	}
84960		- case 18446744073709546192LLU: // 99999998pP'''''''''''''''
	85271	+ case 18446744073709546177LLU: // 99999998pA'''''''''''''''
84961	85272	{
84962	85273	{
84963	85274	uint64_t arg = 0;

		@@ -84964,10 +85275,10 @@
84964	85275	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
84965	85276	}
84966	85277	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 10LLU)));
84967		- state.addr = 18446744073709546190LLU; // 99999998pN'''''''''''''''
	85278	+ state.addr = 18446744073709546175LLU; // 99999998o9'''''''''''''''
84968	85279	break;
84969	85280	}
84970		- case 18446744073709546190LLU: // 99999998pN'''''''''''''''
	85281	+ case 18446744073709546175LLU: // 99999998o9'''''''''''''''
84971	85282	{
84972	85283	{
84973	85284	uint64_t arg = 0;

		@@ -84979,23 +85290,23 @@
84979	85290	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
84980	85291	}
84981	85292	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /buf_______/LOCAL_ACCESS(heap.data, 23LLU, 20LLU) == /shadow____/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU);
84982		- state.addr = 18446744073709546187LLU; // 99999998pK'''''''''''''''
	85293	+ state.addr = 18446744073709546172LLU; // 99999998o6'''''''''''''''
84983	85294	break;
84984	85295	}
84985		- case 18446744073709546187LLU: // 99999998pK'''''''''''''''
	85296	+ case 18446744073709546172LLU: // 99999998o6'''''''''''''''
84986	85297	{
84987		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546189LLU : 18446744073709546188LLU;
	85298	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546174LLU : 18446744073709546173LLU;
84988	85299	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
84989	85300	break;
84990	85301	}
84991		- case 18446744073709546189LLU: // 99999998pM'''''''''''''''
	85302	+ case 18446744073709546174LLU: // 99999998o8'''''''''''''''
84992	85303	{
84993	85304	heap.availilable_size_for_dynamic_objects += 0LLU;
84994	85305	heap.availilable_size_for_dynamic_objects += 0LLU;
84995		- state.addr = 18446744073709546186LLU; // 99999998pJ'''''''''''''''
	85306	+ state.addr = 18446744073709546171LLU; // 99999998o5'''''''''''''''
84996	85307	break;
84997	85308	}
84998		- case 18446744073709546188LLU: // 99999998pL'''''''''''''''
	85309	+ case 18446744073709546173LLU: // 99999998o7'''''''''''''''
84999	85310	{
85000	85311	// ACCUMULATE ARGUMENTS - BEGIN
85001	85312	{

		@@ -85003,7 +85314,7 @@
85003	85314	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85004	85315	}
85005	85316	// ACCUMULATE ARGUMENTS - END
85006		- uint64_t return_to = 18446744073709546184LLU;
	85317	+ uint64_t return_to = 18446744073709546169LLU;
85007	85318	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
85008	85319	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85009	85320	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85012,12 +85323,12 @@
85012	85323	state.addr = 819847183515949359LLU; // reportinit
85013	85324	break;
85014	85325	}
85015		- case 18446744073709546184LLU: // 99999998pH'''''''''''''''
	85326	+ case 18446744073709546169LLU: // 99999998o3'''''''''''''''
85016	85327	{
85017		- state.addr = 18446744073709546185LLU; // 99999998pI'''''''''''''''
	85328	+ state.addr = 18446744073709546170LLU; // 99999998o4'''''''''''''''
85018	85329	break;
85019	85330	}
85020		- case 18446744073709546185LLU: // 99999998pI'''''''''''''''
	85331	+ case 18446744073709546170LLU: // 99999998o4'''''''''''''''
85021	85332	{
85022	85333	fprintf(stderr, "%s", "variable ");
85023	85334	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU));

		@@ -85027,10 +85338,10 @@
85027	85338	fprintf(stderr, "%s\n", "");
85028	85339	exit(-1);
85029	85340	}
85030		- state.addr = 18446744073709546186LLU; // 99999998pJ'''''''''''''''
	85341	+ state.addr = 18446744073709546171LLU; // 99999998o5'''''''''''''''
85031	85342	break;
85032	85343	}
85033		- case 18446744073709546186LLU: // 99999998pJ'''''''''''''''
	85344	+ case 18446744073709546171LLU: // 99999998o5'''''''''''''''
85034	85345	{
85035	85346	// variable u64 shadow____ goes out of scope
85036	85347	// emitted destructur for type u64

		@@ -85038,10 +85349,10 @@
85038	85349	// variable u64 buf_______ goes out of scope
85039	85350	// emitted destructur for type u64
85040	85351	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference buf_______ at 21
85041		- state.addr = 18446744073709546193LLU; // 99999998pQ'''''''''''''''
	85352	+ state.addr = 18446744073709546178LLU; // 99999998pB'''''''''''''''
85042	85353	break;
85043	85354	}
85044		- case 18446744073709546193LLU: // 99999998pQ'''''''''''''''
	85355	+ case 18446744073709546178LLU: // 99999998pB'''''''''''''''
85045	85356	{
85046	85357	// ACCUMULATE ARGUMENTS - BEGIN
85047	85358	{

		@@ -85065,7 +85376,7 @@
85065	85376	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85066	85377	}
85067	85378	// ACCUMULATE ARGUMENTS - END
85068		- uint64_t return_to = 18446744073709546182LLU;
	85379	+ uint64_t return_to = 18446744073709546167LLU;
85069	85380	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
85070	85381	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85071	85382	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85074,12 +85385,12 @@
85074	85385	state.addr = 515555125197130432LLU; // allocheap_
85075	85386	break;
85076	85387	}
85077		- case 18446744073709546182LLU: // 99999998pF'''''''''''''''
	85388	+ case 18446744073709546167LLU: // 99999998o1'''''''''''''''
85078	85389	{
85079		- state.addr = 18446744073709546183LLU; // 99999998pG'''''''''''''''
	85390	+ state.addr = 18446744073709546168LLU; // 99999998o2'''''''''''''''
85080	85391	break;
85081	85392	}
85082		- case 18446744073709546183LLU: // 99999998pG'''''''''''''''
	85393	+ case 18446744073709546168LLU: // 99999998o2'''''''''''''''
85083	85394	{
85084	85395	{
85085	85396	uint64_t arg = 0;

		@@ -85088,7 +85399,7 @@
85088	85399	*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 0;
85089	85400	// ACCUMULATE ARGUMENTS - BEGIN
85090	85401	// ACCUMULATE ARGUMENTS - END
85091		- uint64_t return_to = 18446744073709546179LLU;
	85402	+ uint64_t return_to = 18446744073709546164LLU;
85092	85403	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
85093	85404	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85094	85405	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85097,12 +85408,12 @@
85097	85408	state.addr = 890787671342055424LLU; // varopen___
85098	85409	break;
85099	85410	}
85100		- case 18446744073709546179LLU: // 99999998pC'''''''''''''''
	85411	+ case 18446744073709546164LLU: // 99999998oy'''''''''''''''
85101	85412	{
85102		- state.addr = 18446744073709546180LLU; // 99999998pD'''''''''''''''
	85413	+ state.addr = 18446744073709546165LLU; // 99999998oz'''''''''''''''
85103	85414	break;
85104	85415	}
85105		- case 18446744073709546180LLU: // 99999998pD'''''''''''''''
	85416	+ case 18446744073709546165LLU: // 99999998oz'''''''''''''''
85106	85417	{
85107	85418	fprintf(stdout, "%s", "0");
85108	85419	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -85127,7 +85438,7 @@
85127	85438	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85128	85439	}
85129	85440	// ACCUMULATE ARGUMENTS - END
85130		- uint64_t return_to = 18446744073709546177LLU;
	85441	+ uint64_t return_to = 18446744073709546162LLU;
85131	85442	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
85132	85443	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85133	85444	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85136,12 +85447,12 @@
85136	85447	state.addr = 890786842582581248LLU; // varclose__
85137	85448	break;
85138	85449	}
85139		- case 18446744073709546177LLU: // 99999998pA'''''''''''''''
	85450	+ case 18446744073709546162LLU: // 99999998ow'''''''''''''''
85140	85451	{
85141		- state.addr = 18446744073709546178LLU; // 99999998pB'''''''''''''''
	85452	+ state.addr = 18446744073709546163LLU; // 99999998ox'''''''''''''''
85142	85453	break;
85143	85454	}
85144		- case 18446744073709546178LLU: // 99999998pB'''''''''''''''
	85455	+ case 18446744073709546163LLU: // 99999998ox'''''''''''''''
85145	85456	{
85146	85457	// ACCUMULATE ARGUMENTS - BEGIN
85147	85458	{

		@@ -85149,7 +85460,7 @@
85149	85460	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85150	85461	}
85151	85462	// ACCUMULATE ARGUMENTS - END
85152		- uint64_t return_to = 18446744073709546175LLU;
	85463	+ uint64_t return_to = 18446744073709546160LLU;
85153	85464	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
85154	85465	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85155	85466	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85158,12 +85469,12 @@
85158	85469	state.addr = 839519719621918720LLU; // skipws____
85159	85470	break;
85160	85471	}
85161		- case 18446744073709546175LLU: // 99999998o9'''''''''''''''
	85472	+ case 18446744073709546160LLU: // 99999998ou'''''''''''''''
85162	85473	{
85163		- state.addr = 18446744073709546176LLU; // 99999998p_'''''''''''''''
	85474	+ state.addr = 18446744073709546161LLU; // 99999998ov'''''''''''''''
85164	85475	break;
85165	85476	}
85166		- case 18446744073709546176LLU: // 99999998p_'''''''''''''''
	85477	+ case 18446744073709546161LLU: // 99999998ov'''''''''''''''
85167	85478	{
85168	85479	{
85169	85480	uint64_t arg = 0;

		@@ -85189,7 +85500,7 @@
85189	85500	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85190	85501	}
85191	85502	// ACCUMULATE ARGUMENTS - END
85192		- uint64_t return_to = 18446744073709546173LLU;
	85503	+ uint64_t return_to = 18446744073709546158LLU;
85193	85504	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
85194	85505	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85195	85506	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85198,17 +85509,17 @@
85198	85509	state.addr = 728666047794575267LLU; // matchoptch
85199	85510	break;
85200	85511	}
85201		- case 18446744073709546173LLU: // 99999998o7'''''''''''''''
	85512	+ case 18446744073709546158LLU: // 99999998os'''''''''''''''
85202	85513	{
85203		- state.addr = 18446744073709546174LLU; // 99999998o8'''''''''''''''
	85514	+ state.addr = 18446744073709546159LLU; // 99999998ot'''''''''''''''
85204	85515	break;
85205	85516	}
85206		- case 18446744073709546174LLU: // 99999998o8'''''''''''''''
	85517	+ case 18446744073709546159LLU: // 99999998ot'''''''''''''''
85207	85518	{
85208		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546172LLU : 18446744073709546171LLU;
	85519	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546157LLU : 18446744073709546156LLU;
85209	85520	break;
85210	85521	}
85211		- case 18446744073709546172LLU: // 99999998o6'''''''''''''''
	85522	+ case 18446744073709546157LLU: // 99999998or'''''''''''''''
85212	85523	{
85213	85524	{
85214	85525	uint64_t arg = 0;

		@@ -85229,7 +85540,7 @@
85229	85540	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85230	85541	}
85231	85542	// ACCUMULATE ARGUMENTS - END
85232		- uint64_t return_to = 18446744073709546169LLU;
	85543	+ uint64_t return_to = 18446744073709546154LLU;
85233	85544	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
85234	85545	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85235	85546	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85238,12 +85549,12 @@
85238	85549	state.addr = 661640243165790208LLU; // islist____
85239	85550	break;
85240	85551	}
85241		- case 18446744073709546169LLU: // 99999998o3'''''''''''''''
	85552	+ case 18446744073709546154LLU: // 99999998oo'''''''''''''''
85242	85553	{
85243		- state.addr = 18446744073709546170LLU; // 99999998o4'''''''''''''''
	85554	+ state.addr = 18446744073709546155LLU; // 99999998op'''''''''''''''
85244	85555	break;
85245	85556	}
85246		- case 18446744073709546170LLU: // 99999998o4'''''''''''''''
	85557	+ case 18446744073709546155LLU: // 99999998op'''''''''''''''
85247	85558	{
85248	85559	// ACCUMULATE ARGUMENTS - BEGIN
85249	85560	{

		@@ -85275,7 +85586,7 @@
85275	85586	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85276	85587	}
85277	85588	// ACCUMULATE ARGUMENTS - END
85278		- uint64_t return_to = 18446744073709546167LLU;
	85589	+ uint64_t return_to = 18446744073709546152LLU;
85279	85590	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
85280	85591	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85281	85592	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85284,12 +85595,12 @@
85284	85595	state.addr = 788334703205941248LLU; // pushvar___
85285	85596	break;
85286	85597	}
85287		- case 18446744073709546167LLU: // 99999998o1'''''''''''''''
	85598	+ case 18446744073709546152LLU: // 99999998om'''''''''''''''
85288	85599	{
85289		- state.addr = 18446744073709546168LLU; // 99999998o2'''''''''''''''
	85600	+ state.addr = 18446744073709546153LLU; // 99999998on'''''''''''''''
85290	85601	break;
85291	85602	}
85292		- case 18446744073709546168LLU: // 99999998o2'''''''''''''''
	85603	+ case 18446744073709546153LLU: // 99999998on'''''''''''''''
85293	85604	{
85294	85605	// variable u64 initialize goes out of scope
85295	85606	// emitted destructur for type u64

		@@ -85299,10 +85610,10 @@
85299	85610	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 24
85300	85611	heap.availilable_size_for_dynamic_objects += 0LLU;
85301	85612	heap.availilable_size_for_dynamic_objects += 0LLU;
85302		- state.addr = 18446744073709546166LLU; // 99999998o0'''''''''''''''
	85613	+ state.addr = 18446744073709546151LLU; // 99999998ol'''''''''''''''
85303	85614	break;
85304	85615	}
85305		- case 18446744073709546171LLU: // 99999998o5'''''''''''''''
	85616	+ case 18446744073709546156LLU: // 99999998oq'''''''''''''''
85306	85617	{
85307	85618	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 10LLU)));
85308	85619	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -85311,7 +85622,7 @@
85311	85622	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85312	85623	}
85313	85624	// ACCUMULATE ARGUMENTS - END
85314		- uint64_t return_to = 18446744073709546164LLU;
	85625	+ uint64_t return_to = 18446744073709546149LLU;
85315	85626	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
85316	85627	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85317	85628	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85320,12 +85631,12 @@
85320	85631	state.addr = 839519719621918720LLU; // skipws____
85321	85632	break;
85322	85633	}
85323		- case 18446744073709546164LLU: // 99999998oy'''''''''''''''
	85634	+ case 18446744073709546149LLU: // 99999998oj'''''''''''''''
85324	85635	{
85325		- state.addr = 18446744073709546165LLU; // 99999998oz'''''''''''''''
	85636	+ state.addr = 18446744073709546150LLU; // 99999998ok'''''''''''''''
85326	85637	break;
85327	85638	}
85328		- case 18446744073709546165LLU: // 99999998oz'''''''''''''''
	85639	+ case 18446744073709546150LLU: // 99999998ok'''''''''''''''
85329	85640	{
85330	85641	{
85331	85642	uint64_t arg = 0;

		@@ -85354,7 +85665,7 @@
85354	85665	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85355	85666	}
85356	85667	// ACCUMULATE ARGUMENTS - END
85357		- uint64_t return_to = 18446744073709546162LLU;
	85668	+ uint64_t return_to = 18446744073709546147LLU;
85358	85669	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
85359	85670	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85360	85671	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85363,18 +85674,18 @@
85363	85674	state.addr = 768289076452424640LLU; // oneresult_
85364	85675	break;
85365	85676	}
85366		- case 18446744073709546162LLU: // 99999998ow'''''''''''''''
	85677	+ case 18446744073709546147LLU: // 99999998oh'''''''''''''''
85367	85678	{
85368		- state.addr = 18446744073709546163LLU; // 99999998ox'''''''''''''''
	85679	+ state.addr = 18446744073709546148LLU; // 99999998oi'''''''''''''''
85369	85680	break;
85370	85681	}
85371		- case 18446744073709546163LLU: // 99999998ox'''''''''''''''
	85682	+ case 18446744073709546148LLU: // 99999998oi'''''''''''''''
85372	85683	{
85373	85684
85374		- state.addr = 18446744073709546161LLU; // 99999998ov'''''''''''''''
	85685	+ state.addr = 18446744073709546146LLU; // 99999998og'''''''''''''''
85375	85686	break;
85376	85687	}
85377		- case 18446744073709546161LLU: // 99999998ov'''''''''''''''
	85688	+ case 18446744073709546146LLU: // 99999998og'''''''''''''''
85378	85689	{
85379	85690	*LOCAL_ACCESS(heap.data, 25LLU, 21LLU) = 123;
85380	85691	{

		@@ -85382,21 +85693,21 @@
85382	85693	LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/address of current closure/, &arg);
85383	85694	}
85384	85695	LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = /sym_______/LOCAL_ACCESS(heap.data, 26LLU, 21LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 26LLU, 10LLU));
85385		- state.addr = 18446744073709546158LLU; // 99999998os'''''''''''''''
	85696	+ state.addr = 18446744073709546143LLU; // 99999998od'''''''''''''''
85386	85697	break;
85387	85698	}
85388		- case 18446744073709546158LLU: // 99999998os'''''''''''''''
	85699	+ case 18446744073709546143LLU: // 99999998od'''''''''''''''
85389	85700	{
85390		- state.addr = *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709546160LLU : 18446744073709546159LLU;
	85701	+ state.addr = *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709546145LLU : 18446744073709546144LLU;
85391	85702	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 26
85392	85703	break;
85393	85704	}
85394		- case 18446744073709546160LLU: // 99999998ou'''''''''''''''
	85705	+ case 18446744073709546145LLU: // 99999998of'''''''''''''''
85395	85706	{
85396		- state.addr = *LOCAL_ACCESS(heap.data, 25LLU, 19LLU) ? 18446744073709546157LLU : 18446744073709546156LLU;
	85707	+ state.addr = *LOCAL_ACCESS(heap.data, 25LLU, 19LLU) ? 18446744073709546142LLU : 18446744073709546141LLU;
85397	85708	break;
85398	85709	}
85399		- case 18446744073709546157LLU: // 99999998or'''''''''''''''
	85710	+ case 18446744073709546142LLU: // 99999998oc'''''''''''''''
85400	85711	{
85401	85712	{
85402	85713	uint64_t arg = 0;

		@@ -85408,7 +85719,7 @@
85408	85719	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85409	85720	}
85410	85721	// ACCUMULATE ARGUMENTS - END
85411		- uint64_t return_to = 18446744073709546154LLU;
	85722	+ uint64_t return_to = 18446744073709546139LLU;
85412	85723	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
85413	85724	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85414	85725	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85417,12 +85728,12 @@
85417	85728	state.addr = 861504796319285248LLU; // typeu64___
85418	85729	break;
85419	85730	}
85420		- case 18446744073709546154LLU: // 99999998oo'''''''''''''''
	85731	+ case 18446744073709546139LLU: // 99999998o$'''''''''''''''
85421	85732	{
85422		- state.addr = 18446744073709546155LLU; // 99999998op'''''''''''''''
	85733	+ state.addr = 18446744073709546140LLU; // 99999998oa'''''''''''''''
85423	85734	break;
85424	85735	}
85425		- case 18446744073709546155LLU: // 99999998op'''''''''''''''
	85736	+ case 18446744073709546140LLU: // 99999998oa'''''''''''''''
85426	85737	{
85427	85738	{
85428	85739	uint64_t arg = 0;

		@@ -85509,7 +85820,7 @@
85509	85820	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85510	85821	}
85511	85822	// ACCUMULATE ARGUMENTS - END
85512		- uint64_t return_to = 18446744073709546151LLU;
	85823	+ uint64_t return_to = 18446744073709546136LLU;
85513	85824	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
85514	85825	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85515	85826	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85518,12 +85829,12 @@
85518	85829	state.addr = 604790753280317473LLU; // findvarref
85519	85830	break;
85520	85831	}
85521		- case 18446744073709546151LLU: // 99999998ol'''''''''''''''
	85832	+ case 18446744073709546136LLU: // 99999998oX'''''''''''''''
85522	85833	{
85523		- state.addr = 18446744073709546152LLU; // 99999998om'''''''''''''''
	85834	+ state.addr = 18446744073709546137LLU; // 99999998oY'''''''''''''''
85524	85835	break;
85525	85836	}
85526		- case 18446744073709546152LLU: // 99999998om'''''''''''''''
	85837	+ case 18446744073709546137LLU: // 99999998oY'''''''''''''''
85527	85838	{
85528	85839	// variable u64 consume___ goes out of scope
85529	85840	// emitted destructur for type u64

		@@ -85531,10 +85842,10 @@
85531	85842	// variable u64 optelem___ goes out of scope
85532	85843	// emitted destructur for type u64
85533	85844	(void)LOCAL_POP_MOVE(&heap, 32LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 32
85534		- state.addr = 18446744073709546153LLU; // 99999998on'''''''''''''''
	85845	+ state.addr = 18446744073709546138LLU; // 99999998oZ'''''''''''''''
85535	85846	break;
85536	85847	}
85537		- case 18446744073709546153LLU: // 99999998on'''''''''''''''
	85848	+ case 18446744073709546138LLU: // 99999998oZ'''''''''''''''
85538	85849	{
85539	85850	{
85540	85851	uint64_t arg = 0;

		@@ -85571,7 +85882,7 @@
85571	85882	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85572	85883	}
85573	85884	// ACCUMULATE ARGUMENTS - END
85574		- uint64_t return_to = 18446744073709546148LLU;
	85885	+ uint64_t return_to = 18446744073709546133LLU;
85575	85886	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
85576	85887	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85577	85888	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85580,20 +85891,20 @@
85580	85891	state.addr = 788334703205941248LLU; // pushvar___
85581	85892	break;
85582	85893	}
85583		- case 18446744073709546148LLU: // 99999998oi'''''''''''''''
	85894	+ case 18446744073709546133LLU: // 99999998oU'''''''''''''''
85584	85895	{
85585		- state.addr = 18446744073709546149LLU; // 99999998oj'''''''''''''''
	85896	+ state.addr = 18446744073709546134LLU; // 99999998oV'''''''''''''''
85586	85897	break;
85587	85898	}
85588		- case 18446744073709546149LLU: // 99999998oj'''''''''''''''
	85899	+ case 18446744073709546134LLU: // 99999998oV'''''''''''''''
85589	85900	{
85590	85901	// variable u64 initialize goes out of scope
85591	85902	// emitted destructur for type u64
85592	85903	(void)LOCAL_POP_MOVE(&heap, 32LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference initialize at 32
85593		- state.addr = 18446744073709546150LLU; // 99999998ok'''''''''''''''
	85904	+ state.addr = 18446744073709546135LLU; // 99999998oW'''''''''''''''
85594	85905	break;
85595	85906	}
85596		- case 18446744073709546150LLU: // 99999998ok'''''''''''''''
	85907	+ case 18446744073709546135LLU: // 99999998oW'''''''''''''''
85597	85908	{
85598	85909	// ACCUMULATE ARGUMENTS - BEGIN
85599	85910	{

		@@ -85621,7 +85932,7 @@
85621	85932	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85622	85933	}
85623	85934	// ACCUMULATE ARGUMENTS - END
85624		- uint64_t return_to = 18446744073709546146LLU;
	85935	+ uint64_t return_to = 18446744073709546131LLU;
85625	85936	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
85626	85937	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85627	85938	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85630,12 +85941,12 @@
85630	85941	state.addr = 533581901922699840LLU; // blockopen_
85631	85942	break;
85632	85943	}
85633		- case 18446744073709546146LLU: // 99999998og'''''''''''''''
	85944	+ case 18446744073709546131LLU: // 99999998oS'''''''''''''''
85634	85945	{
85635		- state.addr = 18446744073709546147LLU; // 99999998oh'''''''''''''''
	85946	+ state.addr = 18446744073709546132LLU; // 99999998oT'''''''''''''''
85636	85947	break;
85637	85948	}
85638		- case 18446744073709546147LLU: // 99999998oh'''''''''''''''
	85949	+ case 18446744073709546132LLU: // 99999998oT'''''''''''''''
85639	85950	{
85640	85951	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 31LLU, 15LLU)), &/newresults/*LOCAL_ACCESS(heap.data, 31LLU, 24LLU));
85641	85952	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -85668,7 +85979,7 @@
85668	85979	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85669	85980	}
85670	85981	// ACCUMULATE ARGUMENTS - END
85671		- uint64_t return_to = 18446744073709546143LLU;
	85982	+ uint64_t return_to = 18446744073709546128LLU;
85672	85983	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
85673	85984	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85674	85985	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85677,17 +85988,17 @@
85677	85988	state.addr = 788334703340351488LLU; // pushvirt__
85678	85989	break;
85679	85990	}
85680		- case 18446744073709546143LLU: // 99999998od'''''''''''''''
	85991	+ case 18446744073709546128LLU: // 99999998oP'''''''''''''''
85681	85992	{
85682		- state.addr = 18446744073709546144LLU; // 99999998oe'''''''''''''''
	85993	+ state.addr = 18446744073709546129LLU; // 99999998oQ'''''''''''''''
85683	85994	break;
85684	85995	}
85685		- case 18446744073709546144LLU: // 99999998oe'''''''''''''''
	85996	+ case 18446744073709546129LLU: // 99999998oQ'''''''''''''''
85686	85997	{
85687		- state.addr = 18446744073709546145LLU; // 99999998of'''''''''''''''
	85998	+ state.addr = 18446744073709546130LLU; // 99999998oR'''''''''''''''
85688	85999	break;
85689	86000	}
85690		- case 18446744073709546145LLU: // 99999998of'''''''''''''''
	86001	+ case 18446744073709546130LLU: // 99999998oR'''''''''''''''
85691	86002	{
85692	86003	// variable u64 initialize goes out of scope
85693	86004	// emitted destructur for type u64

		@@ -85712,7 +86023,7 @@
85712	86023	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85713	86024	}
85714	86025	// ACCUMULATE ARGUMENTS - END
85715		- uint64_t return_to = 18446744073709546142LLU;
	86026	+ uint64_t return_to = 18446744073709546127LLU;
85716	86027	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
85717	86028	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85718	86029	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85721,15 +86032,15 @@
85721	86032	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
85722	86033	break;
85723	86034	}
85724		- case 18446744073709546142LLU: // 99999998oc'''''''''''''''
	86035	+ case 18446744073709546127LLU: // 99999998oO'''''''''''''''
85725	86036	{
85726	86037	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 26
85727	86038	heap.availilable_size_for_dynamic_objects += 0LLU;
85728	86039	heap.availilable_size_for_dynamic_objects += 0LLU;
85729		- state.addr = 18446744073709546141LLU; // 99999998ob'''''''''''''''
	86040	+ state.addr = 18446744073709546126LLU; // 99999998oN'''''''''''''''
85730	86041	break;
85731	86042	}
85732		- case 18446744073709546156LLU: // 99999998oq'''''''''''''''
	86043	+ case 18446744073709546141LLU: // 99999998ob'''''''''''''''
85733	86044	{
85734	86045	{
85735	86046	uint64_t arg = 0;

		@@ -85766,7 +86077,7 @@
85766	86077	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85767	86078	}
85768	86079	// ACCUMULATE ARGUMENTS - END
85769		- uint64_t return_to = 18446744073709546138LLU;
	86080	+ uint64_t return_to = 18446744073709546123LLU;
85770	86081	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
85771	86082	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85772	86083	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85775,20 +86086,20 @@
85775	86086	state.addr = 788334703205941248LLU; // pushvar___
85776	86087	break;
85777	86088	}
85778		- case 18446744073709546138LLU: // 99999998oZ'''''''''''''''
	86089	+ case 18446744073709546123LLU: // 99999998oK'''''''''''''''
85779	86090	{
85780		- state.addr = 18446744073709546139LLU; // 99999998o$'''''''''''''''
	86091	+ state.addr = 18446744073709546124LLU; // 99999998oL'''''''''''''''
85781	86092	break;
85782	86093	}
85783		- case 18446744073709546139LLU: // 99999998o$'''''''''''''''
	86094	+ case 18446744073709546124LLU: // 99999998oL'''''''''''''''
85784	86095	{
85785	86096	// variable u64 initialize goes out of scope
85786	86097	// emitted destructur for type u64
85787	86098	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference initialize at 26
85788		- state.addr = 18446744073709546140LLU; // 99999998oa'''''''''''''''
	86099	+ state.addr = 18446744073709546125LLU; // 99999998oM'''''''''''''''
85789	86100	break;
85790	86101	}
85791		- case 18446744073709546140LLU: // 99999998oa'''''''''''''''
	86102	+ case 18446744073709546125LLU: // 99999998oM'''''''''''''''
85792	86103	{
85793	86104	// ACCUMULATE ARGUMENTS - BEGIN
85794	86105	{

		@@ -85816,7 +86127,7 @@
85816	86127	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85817	86128	}
85818	86129	// ACCUMULATE ARGUMENTS - END
85819		- uint64_t return_to = 18446744073709546136LLU;
	86130	+ uint64_t return_to = 18446744073709546121LLU;
85820	86131	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
85821	86132	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85822	86133	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85825,25 +86136,25 @@
85825	86136	state.addr = 533581901922699840LLU; // blockopen_
85826	86137	break;
85827	86138	}
85828		- case 18446744073709546136LLU: // 99999998oX'''''''''''''''
	86139	+ case 18446744073709546121LLU: // 99999998oI'''''''''''''''
85829	86140	{
85830		- state.addr = 18446744073709546137LLU; // 99999998oY'''''''''''''''
	86141	+ state.addr = 18446744073709546122LLU; // 99999998oJ'''''''''''''''
85831	86142	break;
85832	86143	}
85833		- case 18446744073709546137LLU: // 99999998oY'''''''''''''''
	86144	+ case 18446744073709546122LLU: // 99999998oJ'''''''''''''''
85834	86145	{
85835	86146	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 15LLU)), &/newresults/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU));
85836		- state.addr = 18446744073709546141LLU; // 99999998ob'''''''''''''''
	86147	+ state.addr = 18446744073709546126LLU; // 99999998oN'''''''''''''''
85837	86148	break;
85838	86149	}
85839		- case 18446744073709546141LLU: // 99999998ob'''''''''''''''
	86150	+ case 18446744073709546126LLU: // 99999998oN'''''''''''''''
85840	86151	{
85841	86152	heap.availilable_size_for_dynamic_objects += 0LLU;
85842	86153	heap.availilable_size_for_dynamic_objects += 0LLU;
85843		- state.addr = 18446744073709546135LLU; // 99999998oW'''''''''''''''
	86154	+ state.addr = 18446744073709546120LLU; // 99999998oH'''''''''''''''
85844	86155	break;
85845	86156	}
85846		- case 18446744073709546159LLU: // 99999998ot'''''''''''''''
	86157	+ case 18446744073709546144LLU: // 99999998oe'''''''''''''''
85847	86158	{
85848	86159	// ACCUMULATE ARGUMENTS - BEGIN
85849	86160	{

		@@ -85915,7 +86226,7 @@
85915	86226	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85916	86227	}
85917	86228	// ACCUMULATE ARGUMENTS - END
85918		- uint64_t return_to = 18446744073709546133LLU;
	86229	+ uint64_t return_to = 18446744073709546118LLU;
85919	86230	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
85920	86231	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85921	86232	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85924,12 +86235,12 @@
85924	86235	state.addr = 787472338545441824LLU; // procrvalue
85925	86236	break;
85926	86237	}
85927		- case 18446744073709546133LLU: // 99999998oU'''''''''''''''
	86238	+ case 18446744073709546118LLU: // 99999998oF'''''''''''''''
85928	86239	{
85929		- state.addr = 18446744073709546134LLU; // 99999998oV'''''''''''''''
	86240	+ state.addr = 18446744073709546119LLU; // 99999998oG'''''''''''''''
85930	86241	break;
85931	86242	}
85932		- case 18446744073709546134LLU: // 99999998oV'''''''''''''''
	86243	+ case 18446744073709546119LLU: // 99999998oG'''''''''''''''
85933	86244	{
85934	86245	{
85935	86246	uint64_t arg = 0;

		@@ -85966,7 +86277,7 @@
85966	86277	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
85967	86278	}
85968	86279	// ACCUMULATE ARGUMENTS - END
85969		- uint64_t return_to = 18446744073709546130LLU;
	86280	+ uint64_t return_to = 18446744073709546115LLU;
85970	86281	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
85971	86282	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
85972	86283	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -85975,36 +86286,36 @@
85975	86286	state.addr = 788334703205941248LLU; // pushvar___
85976	86287	break;
85977	86288	}
85978		- case 18446744073709546130LLU: // 99999998oR'''''''''''''''
	86289	+ case 18446744073709546115LLU: // 99999998oC'''''''''''''''
85979	86290	{
85980		- state.addr = 18446744073709546131LLU; // 99999998oS'''''''''''''''
	86291	+ state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
85981	86292	break;
85982	86293	}
85983		- case 18446744073709546131LLU: // 99999998oS'''''''''''''''
	86294	+ case 18446744073709546116LLU: // 99999998oD'''''''''''''''
85984	86295	{
85985	86296	// variable u64 initialize goes out of scope
85986	86297	// emitted destructur for type u64
85987	86298	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference initialize at 26
85988		- state.addr = 18446744073709546132LLU; // 99999998oT'''''''''''''''
	86299	+ state.addr = 18446744073709546117LLU; // 99999998oE'''''''''''''''
85989	86300	break;
85990	86301	}
85991		- case 18446744073709546132LLU: // 99999998oT'''''''''''''''
	86302	+ case 18446744073709546117LLU: // 99999998oE'''''''''''''''
85992	86303	{
85993		- state.addr = 18446744073709546135LLU; // 99999998oW'''''''''''''''
	86304	+ state.addr = 18446744073709546120LLU; // 99999998oH'''''''''''''''
85994	86305	break;
85995	86306	}
85996		- case 18446744073709546135LLU: // 99999998oW'''''''''''''''
	86307	+ case 18446744073709546120LLU: // 99999998oH'''''''''''''''
85997	86308	{
85998	86309	// variable list<resdest___> newresults goes out of scope
85999	86310	// emitted destructur for type list<resdest___>
86000		- state.addr = 18446744073709546128LLU; // 99999998oP'''''''''''''''
	86311	+ state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
86001	86312	break;
86002	86313	}
86003		- case 18446744073709546128LLU: // 99999998oP'''''''''''''''
	86314	+ case 18446744073709546113LLU: // 99999998oA'''''''''''''''
86004	86315	{
86005	86316	if(!LOCAL_ACCESS(heap.data, 25LLU, 24LLU)/list*/)
86006	86317	{
86007		- state.addr = 18446744073709546129LLU; // 99999998oQ'''''''''''''''
	86318	+ state.addr = 18446744073709546114LLU; // 99999998oB'''''''''''''''
86008	86319	break;
86009	86320	}
86010	86321	// temporary list-element

		@@ -86018,7 +86329,7 @@
86018	86329	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86019	86330	}
86020	86331	// ACCUMULATE ARGUMENTS - END
86021		- uint64_t return_to = 18446744073709546127LLU;
	86332	+ uint64_t return_to = 18446744073709546112LLU;
86022	86333	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86023	86334	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86024	86335	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86027,23 +86338,23 @@
86027	86338	state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
86028	86339	break;
86029	86340	}
86030		- case 18446744073709546127LLU: // 99999998oO'''''''''''''''
	86341	+ case 18446744073709546112LLU: // 99999998o_'''''''''''''''
86031	86342	{
86032	86343	// RELEASE temporary destructor-variable
86033	86344	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 26
86034		- state.addr = 18446744073709546128LLU; // 99999998oP'''''''''''''''
	86345	+ state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
86035	86346	break;
86036	86347	}
86037		- case 18446744073709546129LLU: // 99999998oQ'''''''''''''''
	86348	+ case 18446744073709546114LLU: // 99999998oB'''''''''''''''
86038	86349	{
86039	86350	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 25
86040	86351	// variable u64 reference_ goes out of scope
86041	86352	// emitted destructur for type u64
86042	86353	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 24
86043		- state.addr = 18446744073709546166LLU; // 99999998o0'''''''''''''''
	86354	+ state.addr = 18446744073709546151LLU; // 99999998ol'''''''''''''''
86044	86355	break;
86045	86356	}
86046		- case 18446744073709546166LLU: // 99999998o0'''''''''''''''
	86357	+ case 18446744073709546151LLU: // 99999998ol'''''''''''''''
86047	86358	{
86048	86359	// variable u64 match_____ goes out of scope
86049	86360	// emitted destructur for type u64

		@@ -86054,10 +86365,10 @@
86054	86365	// variable u64 varidx____ goes out of scope
86055	86366	// emitted destructur for type u64
86056	86367	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 21
86057		- state.addr = 18446744073709546181LLU; // 99999998pE'''''''''''''''
	86368	+ state.addr = 18446744073709546166LLU; // 99999998o0'''''''''''''''
86058	86369	break;
86059	86370	}
86060		- case 18446744073709546181LLU: // 99999998pE'''''''''''''''
	86371	+ case 18446744073709546166LLU: // 99999998o0'''''''''''''''
86061	86372	{
86062	86373	// variable u64 redef_____ goes out of scope
86063	86374	// emitted destructur for type u64

		@@ -86070,7 +86381,7 @@
86070	86381	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86071	86382	}
86072	86383	// ACCUMULATE ARGUMENTS - END
86073		- uint64_t return_to = 18446744073709546126LLU;
	86384	+ uint64_t return_to = 18446744073709546111LLU;
86074	86385	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86075	86386	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86076	86387	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86079,7 +86390,7 @@
86079	86390	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
86080	86391	break;
86081	86392	}
86082		- case 18446744073709546126LLU: // 99999998oN'''''''''''''''
	86393	+ case 18446744073709546111LLU: // 99999998n9'''''''''''''''
86083	86394	{
86084	86395	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedst___ at 19
86085	86396	// variable u64 mutable___ goes out of scope

		@@ -86136,28 +86447,28 @@
86136	86447	}
86137	86448	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0;
86138	86449
86139		- state.addr = 18446744073709546125LLU; // 99999998oM'''''''''''''''
	86450	+ state.addr = 18446744073709546110LLU; // 99999998n8'''''''''''''''
86140	86451	break;
86141	86452	}
86142		- case 18446744073709546125LLU: // 99999998oM'''''''''''''''
	86453	+ case 18446744073709546110LLU: // 99999998n8'''''''''''''''
86143	86454	{
86144	86455	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 876383386118840320;
86145	86456
86146		- state.addr = 18446744073709546124LLU; // 99999998oL'''''''''''''''
	86457	+ state.addr = 18446744073709546109LLU; // 99999998n7'''''''''''''''
86147	86458	break;
86148	86459	}
86149		- case 18446744073709546124LLU: // 99999998oL'''''''''''''''
	86460	+ case 18446744073709546109LLU: // 99999998n7'''''''''''''''
86150	86461	{
86151	86462	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));
86152		- state.addr = 18446744073709546123LLU; // 99999998oK'''''''''''''''
	86463	+ state.addr = 18446744073709546108LLU; // 99999998n6'''''''''''''''
86153	86464	break;
86154	86465	}
86155		- case 18446744073709546123LLU: // 99999998oK'''''''''''''''
	86466	+ case 18446744073709546108LLU: // 99999998n6'''''''''''''''
86156	86467	{
86157		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546122LLU : 18446744073709546121LLU;
	86468	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546107LLU : 18446744073709546106LLU;
86158	86469	break;
86159	86470	}
86160		- case 18446744073709546122LLU: // 99999998oJ'''''''''''''''
	86471	+ case 18446744073709546107LLU: // 99999998n5'''''''''''''''
86161	86472	{
86162	86473	// ACCUMULATE ARGUMENTS - BEGIN
86163	86474	{

		@@ -86165,7 +86476,7 @@
86165	86476	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86166	86477	}
86167	86478	// ACCUMULATE ARGUMENTS - END
86168		- uint64_t return_to = 18446744073709546119LLU;
	86479	+ uint64_t return_to = 18446744073709546104LLU;
86169	86480	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86170	86481	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86171	86482	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86174,12 +86485,12 @@
86174	86485	state.addr = 839519719621918720LLU; // skipws____
86175	86486	break;
86176	86487	}
86177		- case 18446744073709546119LLU: // 99999998oG'''''''''''''''
	86488	+ case 18446744073709546104LLU: // 99999998n2'''''''''''''''
86178	86489	{
86179		- state.addr = 18446744073709546120LLU; // 99999998oH'''''''''''''''
	86490	+ state.addr = 18446744073709546105LLU; // 99999998n3'''''''''''''''
86180	86491	break;
86181	86492	}
86182		- case 18446744073709546120LLU: // 99999998oH'''''''''''''''
	86493	+ case 18446744073709546105LLU: // 99999998n3'''''''''''''''
86183	86494	{
86184	86495	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
86185	86496	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -86188,7 +86499,7 @@
86188	86499	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86189	86500	}
86190	86501	// ACCUMULATE ARGUMENTS - END
86191		- uint64_t return_to = 18446744073709546117LLU;
	86502	+ uint64_t return_to = 18446744073709546102LLU;
86192	86503	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86193	86504	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86194	86505	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86197,12 +86508,12 @@
86197	86508	state.addr = 839519719621918720LLU; // skipws____
86198	86509	break;
86199	86510	}
86200		- case 18446744073709546117LLU: // 99999998oE'''''''''''''''
	86511	+ case 18446744073709546102LLU: // 99999998n0'''''''''''''''
86201	86512	{
86202		- state.addr = 18446744073709546118LLU; // 99999998oF'''''''''''''''
	86513	+ state.addr = 18446744073709546103LLU; // 99999998n1'''''''''''''''
86203	86514	break;
86204	86515	}
86205		- case 18446744073709546118LLU: // 99999998oF'''''''''''''''
	86516	+ case 18446744073709546103LLU: // 99999998n1'''''''''''''''
86206	86517	{
86207	86518	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
86208	86519	if(')' != (char)getchar())

		@@ -86213,34 +86524,34 @@
86213	86524	fprintf(stdout, "%s", "\n ungetc(0, stdin);");
86214	86525	heap.availilable_size_for_dynamic_objects += 0LLU;
86215	86526	heap.availilable_size_for_dynamic_objects += 0LLU;
86216		- state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
	86527	+ state.addr = 18446744073709546101LLU; // 99999998nz'''''''''''''''
86217	86528	break;
86218	86529	}
86219		- case 18446744073709546121LLU: // 99999998oI'''''''''''''''
	86530	+ case 18446744073709546106LLU: // 99999998n4'''''''''''''''
86220	86531	{
86221	86532
86222		- state.addr = 18446744073709546115LLU; // 99999998oC'''''''''''''''
	86533	+ state.addr = 18446744073709546100LLU; // 99999998ny'''''''''''''''
86223	86534	break;
86224	86535	}
86225		- case 18446744073709546115LLU: // 99999998oC'''''''''''''''
	86536	+ case 18446744073709546100LLU: // 99999998ny'''''''''''''''
86226	86537	{
86227	86538	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 605666980531466240;
86228	86539
86229		- state.addr = 18446744073709546114LLU; // 99999998oB'''''''''''''''
	86540	+ state.addr = 18446744073709546099LLU; // 99999998nx'''''''''''''''
86230	86541	break;
86231	86542	}
86232		- case 18446744073709546114LLU: // 99999998oB'''''''''''''''
	86543	+ case 18446744073709546099LLU: // 99999998nx'''''''''''''''
86233	86544	{
86234	86545	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));
86235		- state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
	86546	+ state.addr = 18446744073709546098LLU; // 99999998nw'''''''''''''''
86236	86547	break;
86237	86548	}
86238		- case 18446744073709546113LLU: // 99999998oA'''''''''''''''
	86549	+ case 18446744073709546098LLU: // 99999998nw'''''''''''''''
86239	86550	{
86240		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546112LLU : 18446744073709546111LLU;
	86551	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546097LLU : 18446744073709546096LLU;
86241	86552	break;
86242	86553	}
86243		- case 18446744073709546112LLU: // 99999998o_'''''''''''''''
	86554	+ case 18446744073709546097LLU: // 99999998nv'''''''''''''''
86244	86555	{
86245	86556	// ACCUMULATE ARGUMENTS - BEGIN
86246	86557	{

		@@ -86248,7 +86559,7 @@
86248	86559	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86249	86560	}
86250	86561	// ACCUMULATE ARGUMENTS - END
86251		- uint64_t return_to = 18446744073709546109LLU;
	86562	+ uint64_t return_to = 18446744073709546094LLU;
86252	86563	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86253	86564	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86254	86565	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86257,12 +86568,12 @@
86257	86568	state.addr = 839519719621918720LLU; // skipws____
86258	86569	break;
86259	86570	}
86260		- case 18446744073709546109LLU: // 99999998n7'''''''''''''''
	86571	+ case 18446744073709546094LLU: // 99999998ns'''''''''''''''
86261	86572	{
86262		- state.addr = 18446744073709546110LLU; // 99999998n8'''''''''''''''
	86573	+ state.addr = 18446744073709546095LLU; // 99999998nt'''''''''''''''
86263	86574	break;
86264	86575	}
86265		- case 18446744073709546110LLU: // 99999998n8'''''''''''''''
	86576	+ case 18446744073709546095LLU: // 99999998nt'''''''''''''''
86266	86577	{
86267	86578	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
86268	86579	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -86271,7 +86582,7 @@
86271	86582	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86272	86583	}
86273	86584	// ACCUMULATE ARGUMENTS - END
86274		- uint64_t return_to = 18446744073709546107LLU;
	86585	+ uint64_t return_to = 18446744073709546092LLU;
86275	86586	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86276	86587	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86277	86588	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86280,12 +86591,12 @@
86280	86591	state.addr = 839519719621918720LLU; // skipws____
86281	86592	break;
86282	86593	}
86283		- case 18446744073709546107LLU: // 99999998n5'''''''''''''''
	86594	+ case 18446744073709546092LLU: // 99999998nq'''''''''''''''
86284	86595	{
86285		- state.addr = 18446744073709546108LLU; // 99999998n6'''''''''''''''
	86596	+ state.addr = 18446744073709546093LLU; // 99999998nr'''''''''''''''
86286	86597	break;
86287	86598	}
86288		- case 18446744073709546108LLU: // 99999998n6'''''''''''''''
	86599	+ case 18446744073709546093LLU: // 99999998nr'''''''''''''''
86289	86600	{
86290	86601	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
86291	86602	if(')' != (char)getchar())

		@@ -86296,20 +86607,20 @@
86296	86607	fprintf(stdout, "%s", "\n fflush(stdout);");
86297	86608	heap.availilable_size_for_dynamic_objects += 0LLU;
86298	86609	heap.availilable_size_for_dynamic_objects += 0LLU;
86299		- state.addr = 18446744073709546106LLU; // 99999998n4'''''''''''''''
	86610	+ state.addr = 18446744073709546091LLU; // 99999998np'''''''''''''''
86300	86611	break;
86301	86612	}
86302		- case 18446744073709546111LLU: // 99999998n9'''''''''''''''
	86613	+ case 18446744073709546096LLU: // 99999998nu'''''''''''''''
86303	86614	{
86304		- state.addr = 18446744073709546106LLU; // 99999998n4'''''''''''''''
	86615	+ state.addr = 18446744073709546091LLU; // 99999998np'''''''''''''''
86305	86616	break;
86306	86617	}
86307		- case 18446744073709546106LLU: // 99999998n4'''''''''''''''
	86618	+ case 18446744073709546091LLU: // 99999998np'''''''''''''''
86308	86619	{
86309		- state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
	86620	+ state.addr = 18446744073709546101LLU; // 99999998nz'''''''''''''''
86310	86621	break;
86311	86622	}
86312		- case 18446744073709546116LLU: // 99999998oD'''''''''''''''
	86623	+ case 18446744073709546101LLU: // 99999998nz'''''''''''''''
86313	86624	{
86314	86625	// variable u64 sym_______ goes out of scope
86315	86626	// emitted destructur for type u64

		@@ -86358,28 +86669,28 @@
86358	86669	}
86359	86670	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0;
86360	86671
86361		- state.addr = 18446744073709546105LLU; // 99999998n3'''''''''''''''
	86672	+ state.addr = 18446744073709546090LLU; // 99999998no'''''''''''''''
86362	86673	break;
86363	86674	}
86364		- case 18446744073709546105LLU: // 99999998n3'''''''''''''''
	86675	+ case 18446744073709546090LLU: // 99999998no'''''''''''''''
86365	86676	{
86366	86677	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183514351405;
86367	86678
86368		- state.addr = 18446744073709546104LLU; // 99999998n2'''''''''''''''
	86679	+ state.addr = 18446744073709546089LLU; // 99999998nn'''''''''''''''
86369	86680	break;
86370	86681	}
86371		- case 18446744073709546104LLU: // 99999998n2'''''''''''''''
	86682	+ case 18446744073709546089LLU: // 99999998nn'''''''''''''''
86372	86683	{
86373	86684	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));
86374		- state.addr = 18446744073709546103LLU; // 99999998n1'''''''''''''''
	86685	+ state.addr = 18446744073709546088LLU; // 99999998nm'''''''''''''''
86375	86686	break;
86376	86687	}
86377		- case 18446744073709546103LLU: // 99999998n1'''''''''''''''
	86688	+ case 18446744073709546088LLU: // 99999998nm'''''''''''''''
86378	86689	{
86379		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546102LLU : 18446744073709546101LLU;
	86690	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546087LLU : 18446744073709546086LLU;
86380	86691	break;
86381	86692	}
86382		- case 18446744073709546102LLU: // 99999998n0'''''''''''''''
	86693	+ case 18446744073709546087LLU: // 99999998nl'''''''''''''''
86383	86694	{
86384	86695	{
86385	86696	uint64_t arg = 0;

		@@ -86401,7 +86712,7 @@
86401	86712	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86402	86713	}
86403	86714	// ACCUMULATE ARGUMENTS - END
86404		- uint64_t return_to = 18446744073709546099LLU;
	86715	+ uint64_t return_to = 18446744073709546084LLU;
86405	86716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86406	86717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86407	86718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86410,12 +86721,12 @@
86410	86721	state.addr = 861504796319285248LLU; // typeu64___
86411	86722	break;
86412	86723	}
86413		- case 18446744073709546099LLU: // 99999998nx'''''''''''''''
	86724	+ case 18446744073709546084LLU: // 99999998ni'''''''''''''''
86414	86725	{
86415		- state.addr = 18446744073709546100LLU; // 99999998ny'''''''''''''''
	86726	+ state.addr = 18446744073709546085LLU; // 99999998nj'''''''''''''''
86416	86727	break;
86417	86728	}
86418		- case 18446744073709546100LLU: // 99999998ny'''''''''''''''
	86729	+ case 18446744073709546085LLU: // 99999998nj'''''''''''''''
86419	86730	{
86420	86731	// ACCUMULATE ARGUMENTS - BEGIN
86421	86732	{

		@@ -86423,7 +86734,7 @@
86423	86734	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86424	86735	}
86425	86736	// ACCUMULATE ARGUMENTS - END
86426		- uint64_t return_to = 18446744073709546097LLU;
	86737	+ uint64_t return_to = 18446744073709546082LLU;
86427	86738	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86428	86739	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86429	86740	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86432,12 +86743,12 @@
86432	86743	state.addr = 839519719621918720LLU; // skipws____
86433	86744	break;
86434	86745	}
86435		- case 18446744073709546097LLU: // 99999998nv'''''''''''''''
	86746	+ case 18446744073709546082LLU: // 99999998ng'''''''''''''''
86436	86747	{
86437		- state.addr = 18446744073709546098LLU; // 99999998nw'''''''''''''''
	86748	+ state.addr = 18446744073709546083LLU; // 99999998nh'''''''''''''''
86438	86749	break;
86439	86750	}
86440		- case 18446744073709546098LLU: // 99999998nw'''''''''''''''
	86751	+ case 18446744073709546083LLU: // 99999998nh'''''''''''''''
86441	86752	{
86442	86753	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
86443	86754	fprintf(stdout, "%s", "\n putc((char)");

		@@ -86452,7 +86763,7 @@
86452	86763	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86453	86764	}
86454	86765	// ACCUMULATE ARGUMENTS - END
86455		- uint64_t return_to = 18446744073709546094LLU;
	86766	+ uint64_t return_to = 18446744073709546079LLU;
86456	86767	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86457	86768	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86458	86769	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86461,24 +86772,24 @@
86461	86772	state.addr = 839519719621918720LLU; // skipws____
86462	86773	break;
86463	86774	}
86464		- case 18446744073709546094LLU: // 99999998ns'''''''''''''''
	86775	+ case 18446744073709546079LLU: // 99999998nd'''''''''''''''
86465	86776	{
86466		- state.addr = 18446744073709546095LLU; // 99999998nt'''''''''''''''
	86777	+ state.addr = 18446744073709546080LLU; // 99999998ne'''''''''''''''
86467	86778	break;
86468	86779	}
86469		- case 18446744073709546095LLU: // 99999998nt'''''''''''''''
	86780	+ case 18446744073709546080LLU: // 99999998ne'''''''''''''''
86470	86781	{
86471	86782
86472		- state.addr = 18446744073709546093LLU; // 99999998nr'''''''''''''''
	86783	+ state.addr = 18446744073709546078LLU; // 99999998nc'''''''''''''''
86473	86784	break;
86474	86785	}
86475		- case 18446744073709546093LLU: // 99999998nr'''''''''''''''
	86786	+ case 18446744073709546078LLU: // 99999998nc'''''''''''''''
86476	86787	{
86477	86788	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
86478		- state.addr = 18446744073709546092LLU; // 99999998nq'''''''''''''''
	86789	+ state.addr = 18446744073709546077LLU; // 99999998nb'''''''''''''''
86479	86790	break;
86480	86791	}
86481		- case 18446744073709546092LLU: // 99999998nq'''''''''''''''
	86792	+ case 18446744073709546077LLU: // 99999998nb'''''''''''''''
86482	86793	{
86483	86794	// ACCUMULATE ARGUMENTS - BEGIN
86484	86795	{

		@@ -86498,7 +86809,7 @@
86498	86809	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86499	86810	}
86500	86811	// ACCUMULATE ARGUMENTS - END
86501		- uint64_t return_to = 18446744073709546090LLU;
	86812	+ uint64_t return_to = 18446744073709546075LLU;
86502	86813	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
86503	86814	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86504	86815	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86507,12 +86818,12 @@
86507	86818	state.addr = 517555565473470767LLU; // assertinit
86508	86819	break;
86509	86820	}
86510		- case 18446744073709546090LLU: // 99999998no'''''''''''''''
	86821	+ case 18446744073709546075LLU: // 99999998n$'''''''''''''''
86511	86822	{
86512		- state.addr = 18446744073709546091LLU; // 99999998np'''''''''''''''
	86823	+ state.addr = 18446744073709546076LLU; // 99999998na'''''''''''''''
86513	86824	break;
86514	86825	}
86515		- case 18446744073709546091LLU: // 99999998np'''''''''''''''
	86826	+ case 18446744073709546076LLU: // 99999998na'''''''''''''''
86516	86827	{
86517	86828	{
86518	86829	uint64_t arg = 0;

		@@ -86591,7 +86902,7 @@
86591	86902	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86592	86903	}
86593	86904	// ACCUMULATE ARGUMENTS - END
86594		- uint64_t return_to = 18446744073709546088LLU;
	86905	+ uint64_t return_to = 18446744073709546073LLU;
86595	86906	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
86596	86907	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86597	86908	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86600,12 +86911,12 @@
86600	86911	state.addr = 787472342492567585LLU; // procvarref
86601	86912	break;
86602	86913	}
86603		- case 18446744073709546088LLU: // 99999998nm'''''''''''''''
	86914	+ case 18446744073709546073LLU: // 99999998nY'''''''''''''''
86604	86915	{
86605		- state.addr = 18446744073709546089LLU; // 99999998nn'''''''''''''''
	86916	+ state.addr = 18446744073709546074LLU; // 99999998nZ'''''''''''''''
86606	86917	break;
86607	86918	}
86608		- case 18446744073709546089LLU: // 99999998nn'''''''''''''''
	86919	+ case 18446744073709546074LLU: // 99999998nZ'''''''''''''''
86609	86920	{
86610	86921	// variable u64 initialize goes out of scope
86611	86922	// emitted destructur for type u64

		@@ -86616,10 +86927,10 @@
86616	86927	// variable u64 idx_______ goes out of scope
86617	86928	// emitted destructur for type u64
86618	86929	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
86619		- state.addr = 18446744073709546096LLU; // 99999998nu'''''''''''''''
	86930	+ state.addr = 18446744073709546081LLU; // 99999998nf'''''''''''''''
86620	86931	break;
86621	86932	}
86622		- case 18446744073709546096LLU: // 99999998nu'''''''''''''''
	86933	+ case 18446744073709546081LLU: // 99999998nf'''''''''''''''
86623	86934	{
86624	86935	fprintf(stdout, "%s", ", stderr);");
86625	86936	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -86628,7 +86939,7 @@
86628	86939	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86629	86940	}
86630	86941	// ACCUMULATE ARGUMENTS - END
86631		- uint64_t return_to = 18446744073709546086LLU;
	86942	+ uint64_t return_to = 18446744073709546071LLU;
86632	86943	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86633	86944	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86634	86945	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86637,12 +86948,12 @@
86637	86948	state.addr = 839519719621918720LLU; // skipws____
86638	86949	break;
86639	86950	}
86640		- case 18446744073709546086LLU: // 99999998nk'''''''''''''''
	86951	+ case 18446744073709546071LLU: // 99999998nW'''''''''''''''
86641	86952	{
86642		- state.addr = 18446744073709546087LLU; // 99999998nl'''''''''''''''
	86953	+ state.addr = 18446744073709546072LLU; // 99999998nX'''''''''''''''
86643	86954	break;
86644	86955	}
86645		- case 18446744073709546087LLU: // 99999998nl'''''''''''''''
	86956	+ case 18446744073709546072LLU: // 99999998nX'''''''''''''''
86646	86957	{
86647	86958	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
86648	86959	if(')' != (char)getchar())

		@@ -86660,7 +86971,7 @@
86660	86971	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86661	86972	}
86662	86973	// ACCUMULATE ARGUMENTS - END
86663		- uint64_t return_to = 18446744073709546084LLU;
	86974	+ uint64_t return_to = 18446744073709546069LLU;
86664	86975	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
86665	86976	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86666	86977	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86669,12 +86980,12 @@
86669	86980	state.addr = 517555565476695680LLU; // assertu64_
86670	86981	break;
86671	86982	}
86672		- case 18446744073709546084LLU: // 99999998ni'''''''''''''''
	86983	+ case 18446744073709546069LLU: // 99999998nU'''''''''''''''
86673	86984	{
86674		- state.addr = 18446744073709546085LLU; // 99999998nj'''''''''''''''
	86985	+ state.addr = 18446744073709546070LLU; // 99999998nV'''''''''''''''
86675	86986	break;
86676	86987	}
86677		- case 18446744073709546085LLU: // 99999998nj'''''''''''''''
	86988	+ case 18446744073709546070LLU: // 99999998nV'''''''''''''''
86678	86989	{
86679	86990	// variable u64 mutable___ goes out of scope
86680	86991	// emitted destructur for type u64

		@@ -86687,7 +86998,7 @@
86687	86998	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86688	86999	}
86689	87000	// ACCUMULATE ARGUMENTS - END
86690		- uint64_t return_to = 18446744073709546083LLU;
	87001	+ uint64_t return_to = 18446744073709546068LLU;
86691	87002	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86692	87003	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86693	87004	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86696,7 +87007,7 @@
86696	87007	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
86697	87008	break;
86698	87009	}
86699		- case 18446744073709546083LLU: // 99999998nh'''''''''''''''
	87010	+ case 18446744073709546068LLU: // 99999998nT'''''''''''''''
86700	87011	{
86701	87012	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
86702	87013	// variable u64 INDIRECT__ goes out of scope

		@@ -86707,34 +87018,34 @@
86707	87018	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
86708	87019	heap.availilable_size_for_dynamic_objects += 0LLU;
86709	87020	heap.availilable_size_for_dynamic_objects += 0LLU;
86710		- state.addr = 18446744073709546082LLU; // 99999998ng'''''''''''''''
	87021	+ state.addr = 18446744073709546067LLU; // 99999998nS'''''''''''''''
86711	87022	break;
86712	87023	}
86713		- case 18446744073709546101LLU: // 99999998nz'''''''''''''''
	87024	+ case 18446744073709546086LLU: // 99999998nk'''''''''''''''
86714	87025	{
86715	87026
86716		- state.addr = 18446744073709546081LLU; // 99999998nf'''''''''''''''
	87027	+ state.addr = 18446744073709546066LLU; // 99999998nR'''''''''''''''
86717	87028	break;
86718	87029	}
86719		- case 18446744073709546081LLU: // 99999998nf'''''''''''''''
	87030	+ case 18446744073709546066LLU: // 99999998nR'''''''''''''''
86720	87031	{
86721	87032	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708011125568;
86722	87033
86723		- state.addr = 18446744073709546080LLU; // 99999998ne'''''''''''''''
	87034	+ state.addr = 18446744073709546065LLU; // 99999998nQ'''''''''''''''
86724	87035	break;
86725	87036	}
86726		- case 18446744073709546080LLU: // 99999998ne'''''''''''''''
	87037	+ case 18446744073709546065LLU: // 99999998nQ'''''''''''''''
86727	87038	{
86728	87039	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));
86729		- state.addr = 18446744073709546079LLU; // 99999998nd'''''''''''''''
	87040	+ state.addr = 18446744073709546064LLU; // 99999998nP'''''''''''''''
86730	87041	break;
86731	87042	}
86732		- case 18446744073709546079LLU: // 99999998nd'''''''''''''''
	87043	+ case 18446744073709546064LLU: // 99999998nP'''''''''''''''
86733	87044	{
86734		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546078LLU : 18446744073709546077LLU;
	87045	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546063LLU : 18446744073709546062LLU;
86735	87046	break;
86736	87047	}
86737		- case 18446744073709546078LLU: // 99999998nc'''''''''''''''
	87048	+ case 18446744073709546063LLU: // 99999998nO'''''''''''''''
86738	87049	{
86739	87050	{
86740	87051	uint64_t arg = 0;

		@@ -86756,7 +87067,7 @@
86756	87067	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86757	87068	}
86758	87069	// ACCUMULATE ARGUMENTS - END
86759		- uint64_t return_to = 18446744073709546075LLU;
	87070	+ uint64_t return_to = 18446744073709546060LLU;
86760	87071	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86761	87072	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86762	87073	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86765,12 +87076,12 @@
86765	87076	state.addr = 861504796319285248LLU; // typeu64___
86766	87077	break;
86767	87078	}
86768		- case 18446744073709546075LLU: // 99999998n$'''''''''''''''
	87079	+ case 18446744073709546060LLU: // 99999998nL'''''''''''''''
86769	87080	{
86770		- state.addr = 18446744073709546076LLU; // 99999998na'''''''''''''''
	87081	+ state.addr = 18446744073709546061LLU; // 99999998nM'''''''''''''''
86771	87082	break;
86772	87083	}
86773		- case 18446744073709546076LLU: // 99999998na'''''''''''''''
	87084	+ case 18446744073709546061LLU: // 99999998nM'''''''''''''''
86774	87085	{
86775	87086	// ACCUMULATE ARGUMENTS - BEGIN
86776	87087	{

		@@ -86778,7 +87089,7 @@
86778	87089	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86779	87090	}
86780	87091	// ACCUMULATE ARGUMENTS - END
86781		- uint64_t return_to = 18446744073709546073LLU;
	87092	+ uint64_t return_to = 18446744073709546058LLU;
86782	87093	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86783	87094	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86784	87095	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86787,12 +87098,12 @@
86787	87098	state.addr = 839519719621918720LLU; // skipws____
86788	87099	break;
86789	87100	}
86790		- case 18446744073709546073LLU: // 99999998nY'''''''''''''''
	87101	+ case 18446744073709546058LLU: // 99999998nJ'''''''''''''''
86791	87102	{
86792		- state.addr = 18446744073709546074LLU; // 99999998nZ'''''''''''''''
	87103	+ state.addr = 18446744073709546059LLU; // 99999998nK'''''''''''''''
86793	87104	break;
86794	87105	}
86795		- case 18446744073709546074LLU: // 99999998nZ'''''''''''''''
	87106	+ case 18446744073709546059LLU: // 99999998nK'''''''''''''''
86796	87107	{
86797	87108	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
86798	87109	fprintf(stdout, "%s", "\n putc((char)");

		@@ -86807,7 +87118,7 @@
86807	87118	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86808	87119	}
86809	87120	// ACCUMULATE ARGUMENTS - END
86810		- uint64_t return_to = 18446744073709546070LLU;
	87121	+ uint64_t return_to = 18446744073709546055LLU;
86811	87122	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86812	87123	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86813	87124	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86816,24 +87127,24 @@
86816	87127	state.addr = 839519719621918720LLU; // skipws____
86817	87128	break;
86818	87129	}
86819		- case 18446744073709546070LLU: // 99999998nV'''''''''''''''
	87130	+ case 18446744073709546055LLU: // 99999998nG'''''''''''''''
86820	87131	{
86821		- state.addr = 18446744073709546071LLU; // 99999998nW'''''''''''''''
	87132	+ state.addr = 18446744073709546056LLU; // 99999998nH'''''''''''''''
86822	87133	break;
86823	87134	}
86824		- case 18446744073709546071LLU: // 99999998nW'''''''''''''''
	87135	+ case 18446744073709546056LLU: // 99999998nH'''''''''''''''
86825	87136	{
86826	87137
86827		- state.addr = 18446744073709546069LLU; // 99999998nU'''''''''''''''
	87138	+ state.addr = 18446744073709546054LLU; // 99999998nF'''''''''''''''
86828	87139	break;
86829	87140	}
86830		- case 18446744073709546069LLU: // 99999998nU'''''''''''''''
	87141	+ case 18446744073709546054LLU: // 99999998nF'''''''''''''''
86831	87142	{
86832	87143	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
86833		- state.addr = 18446744073709546068LLU; // 99999998nT'''''''''''''''
	87144	+ state.addr = 18446744073709546053LLU; // 99999998nE'''''''''''''''
86834	87145	break;
86835	87146	}
86836		- case 18446744073709546068LLU: // 99999998nT'''''''''''''''
	87147	+ case 18446744073709546053LLU: // 99999998nE'''''''''''''''
86837	87148	{
86838	87149	// ACCUMULATE ARGUMENTS - BEGIN
86839	87150	{

		@@ -86853,7 +87164,7 @@
86853	87164	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86854	87165	}
86855	87166	// ACCUMULATE ARGUMENTS - END
86856		- uint64_t return_to = 18446744073709546066LLU;
	87167	+ uint64_t return_to = 18446744073709546051LLU;
86857	87168	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
86858	87169	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86859	87170	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86862,12 +87173,12 @@
86862	87173	state.addr = 517555565473470767LLU; // assertinit
86863	87174	break;
86864	87175	}
86865		- case 18446744073709546066LLU: // 99999998nR'''''''''''''''
	87176	+ case 18446744073709546051LLU: // 99999998nC'''''''''''''''
86866	87177	{
86867		- state.addr = 18446744073709546067LLU; // 99999998nS'''''''''''''''
	87178	+ state.addr = 18446744073709546052LLU; // 99999998nD'''''''''''''''
86868	87179	break;
86869	87180	}
86870		- case 18446744073709546067LLU: // 99999998nS'''''''''''''''
	87181	+ case 18446744073709546052LLU: // 99999998nD'''''''''''''''
86871	87182	{
86872	87183	{
86873	87184	uint64_t arg = 0;

		@@ -86946,7 +87257,7 @@
86946	87257	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86947	87258	}
86948	87259	// ACCUMULATE ARGUMENTS - END
86949		- uint64_t return_to = 18446744073709546064LLU;
	87260	+ uint64_t return_to = 18446744073709546049LLU;
86950	87261	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
86951	87262	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86952	87263	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86955,12 +87266,12 @@
86955	87266	state.addr = 787472342492567585LLU; // procvarref
86956	87267	break;
86957	87268	}
86958		- case 18446744073709546064LLU: // 99999998nP'''''''''''''''
	87269	+ case 18446744073709546049LLU: // 99999998nA'''''''''''''''
86959	87270	{
86960		- state.addr = 18446744073709546065LLU; // 99999998nQ'''''''''''''''
	87271	+ state.addr = 18446744073709546050LLU; // 99999998nB'''''''''''''''
86961	87272	break;
86962	87273	}
86963		- case 18446744073709546065LLU: // 99999998nQ'''''''''''''''
	87274	+ case 18446744073709546050LLU: // 99999998nB'''''''''''''''
86964	87275	{
86965	87276	// variable u64 initialize goes out of scope
86966	87277	// emitted destructur for type u64

		@@ -86971,10 +87282,10 @@
86971	87282	// variable u64 idx_______ goes out of scope
86972	87283	// emitted destructur for type u64
86973	87284	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
86974		- state.addr = 18446744073709546072LLU; // 99999998nX'''''''''''''''
	87285	+ state.addr = 18446744073709546057LLU; // 99999998nI'''''''''''''''
86975	87286	break;
86976	87287	}
86977		- case 18446744073709546072LLU: // 99999998nX'''''''''''''''
	87288	+ case 18446744073709546057LLU: // 99999998nI'''''''''''''''
86978	87289	{
86979	87290	fprintf(stdout, "%s", ", stdout);");
86980	87291	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -86983,7 +87294,7 @@
86983	87294	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
86984	87295	}
86985	87296	// ACCUMULATE ARGUMENTS - END
86986		- uint64_t return_to = 18446744073709546062LLU;
	87297	+ uint64_t return_to = 18446744073709546047LLU;
86987	87298	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
86988	87299	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
86989	87300	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -86992,12 +87303,12 @@
86992	87303	state.addr = 839519719621918720LLU; // skipws____
86993	87304	break;
86994	87305	}
86995		- case 18446744073709546062LLU: // 99999998nN'''''''''''''''
	87306	+ case 18446744073709546047LLU: // 99999998m9'''''''''''''''
86996	87307	{
86997		- state.addr = 18446744073709546063LLU; // 99999998nO'''''''''''''''
	87308	+ state.addr = 18446744073709546048LLU; // 99999998n_'''''''''''''''
86998	87309	break;
86999	87310	}
87000		- case 18446744073709546063LLU: // 99999998nO'''''''''''''''
	87311	+ case 18446744073709546048LLU: // 99999998n_'''''''''''''''
87001	87312	{
87002	87313	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
87003	87314	if(')' != (char)getchar())

		@@ -87015,7 +87326,7 @@
87015	87326	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87016	87327	}
87017	87328	// ACCUMULATE ARGUMENTS - END
87018		- uint64_t return_to = 18446744073709546060LLU;
	87329	+ uint64_t return_to = 18446744073709546045LLU;
87019	87330	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
87020	87331	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87021	87332	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87024,12 +87335,12 @@
87024	87335	state.addr = 517555565476695680LLU; // assertu64_
87025	87336	break;
87026	87337	}
87027		- case 18446744073709546060LLU: // 99999998nL'''''''''''''''
	87338	+ case 18446744073709546045LLU: // 99999998m7'''''''''''''''
87028	87339	{
87029		- state.addr = 18446744073709546061LLU; // 99999998nM'''''''''''''''
	87340	+ state.addr = 18446744073709546046LLU; // 99999998m8'''''''''''''''
87030	87341	break;
87031	87342	}
87032		- case 18446744073709546061LLU: // 99999998nM'''''''''''''''
	87343	+ case 18446744073709546046LLU: // 99999998m8'''''''''''''''
87033	87344	{
87034	87345	// variable u64 mutable___ goes out of scope
87035	87346	// emitted destructur for type u64

		@@ -87042,7 +87353,7 @@
87042	87353	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87043	87354	}
87044	87355	// ACCUMULATE ARGUMENTS - END
87045		- uint64_t return_to = 18446744073709546059LLU;
	87356	+ uint64_t return_to = 18446744073709546044LLU;
87046	87357	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87047	87358	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87048	87359	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87051,7 +87362,7 @@
87051	87362	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
87052	87363	break;
87053	87364	}
87054		- case 18446744073709546059LLU: // 99999998nK'''''''''''''''
	87365	+ case 18446744073709546044LLU: // 99999998m6'''''''''''''''
87055	87366	{
87056	87367	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
87057	87368	// variable u64 INDIRECT__ goes out of scope

		@@ -87062,34 +87373,34 @@
87062	87373	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
87063	87374	heap.availilable_size_for_dynamic_objects += 0LLU;
87064	87375	heap.availilable_size_for_dynamic_objects += 0LLU;
87065		- state.addr = 18446744073709546058LLU; // 99999998nJ'''''''''''''''
	87376	+ state.addr = 18446744073709546043LLU; // 99999998m5'''''''''''''''
87066	87377	break;
87067	87378	}
87068		- case 18446744073709546077LLU: // 99999998nb'''''''''''''''
	87379	+ case 18446744073709546062LLU: // 99999998nN'''''''''''''''
87069	87380	{
87070	87381
87071		- state.addr = 18446744073709546057LLU; // 99999998nI'''''''''''''''
	87382	+ state.addr = 18446744073709546042LLU; // 99999998m4'''''''''''''''
87072	87383	break;
87073	87384	}
87074		- case 18446744073709546057LLU: // 99999998nI'''''''''''''''
	87385	+ case 18446744073709546042LLU: // 99999998m4'''''''''''''''
87075	87386	{
87076	87387	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708110622720;
87077	87388
87078		- state.addr = 18446744073709546056LLU; // 99999998nH'''''''''''''''
	87389	+ state.addr = 18446744073709546041LLU; // 99999998m3'''''''''''''''
87079	87390	break;
87080	87391	}
87081		- case 18446744073709546056LLU: // 99999998nH'''''''''''''''
	87392	+ case 18446744073709546041LLU: // 99999998m3'''''''''''''''
87082	87393	{
87083	87394	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));
87084		- state.addr = 18446744073709546055LLU; // 99999998nG'''''''''''''''
	87395	+ state.addr = 18446744073709546040LLU; // 99999998m2'''''''''''''''
87085	87396	break;
87086	87397	}
87087		- case 18446744073709546055LLU: // 99999998nG'''''''''''''''
	87398	+ case 18446744073709546040LLU: // 99999998m2'''''''''''''''
87088	87399	{
87089		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546054LLU : 18446744073709546053LLU;
	87400	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546039LLU : 18446744073709546038LLU;
87090	87401	break;
87091	87402	}
87092		- case 18446744073709546054LLU: // 99999998nF'''''''''''''''
	87403	+ case 18446744073709546039LLU: // 99999998m1'''''''''''''''
87093	87404	{
87094	87405	{
87095	87406	uint64_t arg = 0;

		@@ -87111,7 +87422,7 @@
87111	87422	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87112	87423	}
87113	87424	// ACCUMULATE ARGUMENTS - END
87114		- uint64_t return_to = 18446744073709546051LLU;
	87425	+ uint64_t return_to = 18446744073709546036LLU;
87115	87426	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87116	87427	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87117	87428	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87120,12 +87431,12 @@
87120	87431	state.addr = 861504796319285248LLU; // typeu64___
87121	87432	break;
87122	87433	}
87123		- case 18446744073709546051LLU: // 99999998nC'''''''''''''''
	87434	+ case 18446744073709546036LLU: // 99999998my'''''''''''''''
87124	87435	{
87125		- state.addr = 18446744073709546052LLU; // 99999998nD'''''''''''''''
	87436	+ state.addr = 18446744073709546037LLU; // 99999998mz'''''''''''''''
87126	87437	break;
87127	87438	}
87128		- case 18446744073709546052LLU: // 99999998nD'''''''''''''''
	87439	+ case 18446744073709546037LLU: // 99999998mz'''''''''''''''
87129	87440	{
87130	87441	// ACCUMULATE ARGUMENTS - BEGIN
87131	87442	{

		@@ -87133,7 +87444,7 @@
87133	87444	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87134	87445	}
87135	87446	// ACCUMULATE ARGUMENTS - END
87136		- uint64_t return_to = 18446744073709546049LLU;
	87447	+ uint64_t return_to = 18446744073709546034LLU;
87137	87448	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87138	87449	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87139	87450	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87142,12 +87453,12 @@
87142	87453	state.addr = 839519719621918720LLU; // skipws____
87143	87454	break;
87144	87455	}
87145		- case 18446744073709546049LLU: // 99999998nA'''''''''''''''
	87456	+ case 18446744073709546034LLU: // 99999998mw'''''''''''''''
87146	87457	{
87147		- state.addr = 18446744073709546050LLU; // 99999998nB'''''''''''''''
	87458	+ state.addr = 18446744073709546035LLU; // 99999998mx'''''''''''''''
87148	87459	break;
87149	87460	}
87150		- case 18446744073709546050LLU: // 99999998nB'''''''''''''''
	87461	+ case 18446744073709546035LLU: // 99999998mx'''''''''''''''
87151	87462	{
87152	87463	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
87153	87464	fprintf(stdout, "%s", "\n printid(stdout, ");

		@@ -87162,7 +87473,7 @@
87162	87473	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87163	87474	}
87164	87475	// ACCUMULATE ARGUMENTS - END
87165		- uint64_t return_to = 18446744073709546046LLU;
	87476	+ uint64_t return_to = 18446744073709546031LLU;
87166	87477	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87167	87478	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87168	87479	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87171,24 +87482,24 @@
87171	87482	state.addr = 839519719621918720LLU; // skipws____
87172	87483	break;
87173	87484	}
87174		- case 18446744073709546046LLU: // 99999998m8'''''''''''''''
	87485	+ case 18446744073709546031LLU: // 99999998mt'''''''''''''''
87175	87486	{
87176		- state.addr = 18446744073709546047LLU; // 99999998m9'''''''''''''''
	87487	+ state.addr = 18446744073709546032LLU; // 99999998mu'''''''''''''''
87177	87488	break;
87178	87489	}
87179		- case 18446744073709546047LLU: // 99999998m9'''''''''''''''
	87490	+ case 18446744073709546032LLU: // 99999998mu'''''''''''''''
87180	87491	{
87181	87492
87182		- state.addr = 18446744073709546045LLU; // 99999998m7'''''''''''''''
	87493	+ state.addr = 18446744073709546030LLU; // 99999998ms'''''''''''''''
87183	87494	break;
87184	87495	}
87185		- case 18446744073709546045LLU: // 99999998m7'''''''''''''''
	87496	+ case 18446744073709546030LLU: // 99999998ms'''''''''''''''
87186	87497	{
87187	87498	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
87188		- state.addr = 18446744073709546044LLU; // 99999998m6'''''''''''''''
	87499	+ state.addr = 18446744073709546029LLU; // 99999998mr'''''''''''''''
87189	87500	break;
87190	87501	}
87191		- case 18446744073709546044LLU: // 99999998m6'''''''''''''''
	87502	+ case 18446744073709546029LLU: // 99999998mr'''''''''''''''
87192	87503	{
87193	87504	// ACCUMULATE ARGUMENTS - BEGIN
87194	87505	{

		@@ -87208,7 +87519,7 @@
87208	87519	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87209	87520	}
87210	87521	// ACCUMULATE ARGUMENTS - END
87211		- uint64_t return_to = 18446744073709546042LLU;
	87522	+ uint64_t return_to = 18446744073709546027LLU;
87212	87523	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
87213	87524	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87214	87525	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87217,12 +87528,12 @@
87217	87528	state.addr = 517555565473470767LLU; // assertinit
87218	87529	break;
87219	87530	}
87220		- case 18446744073709546042LLU: // 99999998m4'''''''''''''''
	87531	+ case 18446744073709546027LLU: // 99999998mp'''''''''''''''
87221	87532	{
87222		- state.addr = 18446744073709546043LLU; // 99999998m5'''''''''''''''
	87533	+ state.addr = 18446744073709546028LLU; // 99999998mq'''''''''''''''
87223	87534	break;
87224	87535	}
87225		- case 18446744073709546043LLU: // 99999998m5'''''''''''''''
	87536	+ case 18446744073709546028LLU: // 99999998mq'''''''''''''''
87226	87537	{
87227	87538	{
87228	87539	uint64_t arg = 0;

		@@ -87301,7 +87612,7 @@
87301	87612	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87302	87613	}
87303	87614	// ACCUMULATE ARGUMENTS - END
87304		- uint64_t return_to = 18446744073709546040LLU;
	87615	+ uint64_t return_to = 18446744073709546025LLU;
87305	87616	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
87306	87617	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87307	87618	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87310,12 +87621,12 @@
87310	87621	state.addr = 787472342492567585LLU; // procvarref
87311	87622	break;
87312	87623	}
87313		- case 18446744073709546040LLU: // 99999998m2'''''''''''''''
	87624	+ case 18446744073709546025LLU: // 99999998mn'''''''''''''''
87314	87625	{
87315		- state.addr = 18446744073709546041LLU; // 99999998m3'''''''''''''''
	87626	+ state.addr = 18446744073709546026LLU; // 99999998mo'''''''''''''''
87316	87627	break;
87317	87628	}
87318		- case 18446744073709546041LLU: // 99999998m3'''''''''''''''
	87629	+ case 18446744073709546026LLU: // 99999998mo'''''''''''''''
87319	87630	{
87320	87631	// variable u64 initialize goes out of scope
87321	87632	// emitted destructur for type u64

		@@ -87326,10 +87637,10 @@
87326	87637	// variable u64 idx_______ goes out of scope
87327	87638	// emitted destructur for type u64
87328	87639	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
87329		- state.addr = 18446744073709546048LLU; // 99999998n_'''''''''''''''
	87640	+ state.addr = 18446744073709546033LLU; // 99999998mv'''''''''''''''
87330	87641	break;
87331	87642	}
87332		- case 18446744073709546048LLU: // 99999998n_'''''''''''''''
	87643	+ case 18446744073709546033LLU: // 99999998mv'''''''''''''''
87333	87644	{
87334	87645	fprintf(stdout, "%s", ");");
87335	87646	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -87338,7 +87649,7 @@
87338	87649	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87339	87650	}
87340	87651	// ACCUMULATE ARGUMENTS - END
87341		- uint64_t return_to = 18446744073709546038LLU;
	87652	+ uint64_t return_to = 18446744073709546023LLU;
87342	87653	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87343	87654	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87344	87655	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87347,12 +87658,12 @@
87347	87658	state.addr = 839519719621918720LLU; // skipws____
87348	87659	break;
87349	87660	}
87350		- case 18446744073709546038LLU: // 99999998m0'''''''''''''''
	87661	+ case 18446744073709546023LLU: // 99999998ml'''''''''''''''
87351	87662	{
87352		- state.addr = 18446744073709546039LLU; // 99999998m1'''''''''''''''
	87663	+ state.addr = 18446744073709546024LLU; // 99999998mm'''''''''''''''
87353	87664	break;
87354	87665	}
87355		- case 18446744073709546039LLU: // 99999998m1'''''''''''''''
	87666	+ case 18446744073709546024LLU: // 99999998mm'''''''''''''''
87356	87667	{
87357	87668	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
87358	87669	if(')' != (char)getchar())

		@@ -87370,7 +87681,7 @@
87370	87681	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87371	87682	}
87372	87683	// ACCUMULATE ARGUMENTS - END
87373		- uint64_t return_to = 18446744073709546036LLU;
	87684	+ uint64_t return_to = 18446744073709546021LLU;
87374	87685	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
87375	87686	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87376	87687	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87379,12 +87690,12 @@
87379	87690	state.addr = 517555565476695680LLU; // assertu64_
87380	87691	break;
87381	87692	}
87382		- case 18446744073709546036LLU: // 99999998my'''''''''''''''
	87693	+ case 18446744073709546021LLU: // 99999998mj'''''''''''''''
87383	87694	{
87384		- state.addr = 18446744073709546037LLU; // 99999998mz'''''''''''''''
	87695	+ state.addr = 18446744073709546022LLU; // 99999998mk'''''''''''''''
87385	87696	break;
87386	87697	}
87387		- case 18446744073709546037LLU: // 99999998mz'''''''''''''''
	87698	+ case 18446744073709546022LLU: // 99999998mk'''''''''''''''
87388	87699	{
87389	87700	// variable u64 mutable___ goes out of scope
87390	87701	// emitted destructur for type u64

		@@ -87397,7 +87708,7 @@
87397	87708	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87398	87709	}
87399	87710	// ACCUMULATE ARGUMENTS - END
87400		- uint64_t return_to = 18446744073709546035LLU;
	87711	+ uint64_t return_to = 18446744073709546020LLU;
87401	87712	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87402	87713	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87403	87714	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87406,7 +87717,7 @@
87406	87717	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
87407	87718	break;
87408	87719	}
87409		- case 18446744073709546035LLU: // 99999998mx'''''''''''''''
	87720	+ case 18446744073709546020LLU: // 99999998mi'''''''''''''''
87410	87721	{
87411	87722	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
87412	87723	// variable u64 INDIRECT__ goes out of scope

		@@ -87417,34 +87728,34 @@
87417	87728	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
87418	87729	heap.availilable_size_for_dynamic_objects += 0LLU;
87419	87730	heap.availilable_size_for_dynamic_objects += 0LLU;
87420		- state.addr = 18446744073709546034LLU; // 99999998mw'''''''''''''''
	87731	+ state.addr = 18446744073709546019LLU; // 99999998mh'''''''''''''''
87421	87732	break;
87422	87733	}
87423		- case 18446744073709546053LLU: // 99999998nE'''''''''''''''
	87734	+ case 18446744073709546038LLU: // 99999998m0'''''''''''''''
87424	87735	{
87425	87736
87426		- state.addr = 18446744073709546033LLU; // 99999998mv'''''''''''''''
	87737	+ state.addr = 18446744073709546018LLU; // 99999998mg'''''''''''''''
87427	87738	break;
87428	87739	}
87429		- case 18446744073709546033LLU: // 99999998mv'''''''''''''''
	87740	+ case 18446744073709546018LLU: // 99999998mg'''''''''''''''
87430	87741	{
87431	87742	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183515906048;
87432	87743
87433		- state.addr = 18446744073709546032LLU; // 99999998mu'''''''''''''''
	87744	+ state.addr = 18446744073709546017LLU; // 99999998mf'''''''''''''''
87434	87745	break;
87435	87746	}
87436		- case 18446744073709546032LLU: // 99999998mu'''''''''''''''
	87747	+ case 18446744073709546017LLU: // 99999998mf'''''''''''''''
87437	87748	{
87438	87749	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));
87439		- state.addr = 18446744073709546031LLU; // 99999998mt'''''''''''''''
	87750	+ state.addr = 18446744073709546016LLU; // 99999998me'''''''''''''''
87440	87751	break;
87441	87752	}
87442		- case 18446744073709546031LLU: // 99999998mt'''''''''''''''
	87753	+ case 18446744073709546016LLU: // 99999998me'''''''''''''''
87443	87754	{
87444		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546030LLU : 18446744073709546029LLU;
	87755	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546015LLU : 18446744073709546014LLU;
87445	87756	break;
87446	87757	}
87447		- case 18446744073709546030LLU: // 99999998ms'''''''''''''''
	87758	+ case 18446744073709546015LLU: // 99999998md'''''''''''''''
87448	87759	{
87449	87760	{
87450	87761	uint64_t arg = 0;

		@@ -87466,7 +87777,7 @@
87466	87777	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87467	87778	}
87468	87779	// ACCUMULATE ARGUMENTS - END
87469		- uint64_t return_to = 18446744073709546027LLU;
	87780	+ uint64_t return_to = 18446744073709546012LLU;
87470	87781	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87471	87782	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87472	87783	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87475,12 +87786,12 @@
87475	87786	state.addr = 861504796319285248LLU; // typeu64___
87476	87787	break;
87477	87788	}
87478		- case 18446744073709546027LLU: // 99999998mp'''''''''''''''
	87789	+ case 18446744073709546012LLU: // 99999998ma'''''''''''''''
87479	87790	{
87480		- state.addr = 18446744073709546028LLU; // 99999998mq'''''''''''''''
	87791	+ state.addr = 18446744073709546013LLU; // 99999998mb'''''''''''''''
87481	87792	break;
87482	87793	}
87483		- case 18446744073709546028LLU: // 99999998mq'''''''''''''''
	87794	+ case 18446744073709546013LLU: // 99999998mb'''''''''''''''
87484	87795	{
87485	87796	// ACCUMULATE ARGUMENTS - BEGIN
87486	87797	{

		@@ -87488,7 +87799,7 @@
87488	87799	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87489	87800	}
87490	87801	// ACCUMULATE ARGUMENTS - END
87491		- uint64_t return_to = 18446744073709546025LLU;
	87802	+ uint64_t return_to = 18446744073709546010LLU;
87492	87803	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87493	87804	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87494	87805	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87497,12 +87808,12 @@
87497	87808	state.addr = 839519719621918720LLU; // skipws____
87498	87809	break;
87499	87810	}
87500		- case 18446744073709546025LLU: // 99999998mn'''''''''''''''
	87811	+ case 18446744073709546010LLU: // 99999998mZ'''''''''''''''
87501	87812	{
87502		- state.addr = 18446744073709546026LLU; // 99999998mo'''''''''''''''
	87813	+ state.addr = 18446744073709546011LLU; // 99999998m$'''''''''''''''
87503	87814	break;
87504	87815	}
87505		- case 18446744073709546026LLU: // 99999998mo'''''''''''''''
	87816	+ case 18446744073709546011LLU: // 99999998m$'''''''''''''''
87506	87817	{
87507	87818	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
87508	87819	fprintf(stdout, "%s", "\n printid(stderr, ");

		@@ -87517,7 +87828,7 @@
87517	87828	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87518	87829	}
87519	87830	// ACCUMULATE ARGUMENTS - END
87520		- uint64_t return_to = 18446744073709546022LLU;
	87831	+ uint64_t return_to = 18446744073709546007LLU;
87521	87832	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87522	87833	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87523	87834	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87526,24 +87837,24 @@
87526	87837	state.addr = 839519719621918720LLU; // skipws____
87527	87838	break;
87528	87839	}
87529		- case 18446744073709546022LLU: // 99999998mk'''''''''''''''
	87840	+ case 18446744073709546007LLU: // 99999998mW'''''''''''''''
87530	87841	{
87531		- state.addr = 18446744073709546023LLU; // 99999998ml'''''''''''''''
	87842	+ state.addr = 18446744073709546008LLU; // 99999998mX'''''''''''''''
87532	87843	break;
87533	87844	}
87534		- case 18446744073709546023LLU: // 99999998ml'''''''''''''''
	87845	+ case 18446744073709546008LLU: // 99999998mX'''''''''''''''
87535	87846	{
87536	87847
87537		- state.addr = 18446744073709546021LLU; // 99999998mj'''''''''''''''
	87848	+ state.addr = 18446744073709546006LLU; // 99999998mV'''''''''''''''
87538	87849	break;
87539	87850	}
87540		- case 18446744073709546021LLU: // 99999998mj'''''''''''''''
	87851	+ case 18446744073709546006LLU: // 99999998mV'''''''''''''''
87541	87852	{
87542	87853	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
87543		- state.addr = 18446744073709546020LLU; // 99999998mi'''''''''''''''
	87854	+ state.addr = 18446744073709546005LLU; // 99999998mU'''''''''''''''
87544	87855	break;
87545	87856	}
87546		- case 18446744073709546020LLU: // 99999998mi'''''''''''''''
	87857	+ case 18446744073709546005LLU: // 99999998mU'''''''''''''''
87547	87858	{
87548	87859	// ACCUMULATE ARGUMENTS - BEGIN
87549	87860	{

		@@ -87563,7 +87874,7 @@
87563	87874	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87564	87875	}
87565	87876	// ACCUMULATE ARGUMENTS - END
87566		- uint64_t return_to = 18446744073709546018LLU;
	87877	+ uint64_t return_to = 18446744073709546003LLU;
87567	87878	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
87568	87879	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87569	87880	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87572,12 +87883,12 @@
87572	87883	state.addr = 517555565473470767LLU; // assertinit
87573	87884	break;
87574	87885	}
87575		- case 18446744073709546018LLU: // 99999998mg'''''''''''''''
	87886	+ case 18446744073709546003LLU: // 99999998mS'''''''''''''''
87576	87887	{
87577		- state.addr = 18446744073709546019LLU; // 99999998mh'''''''''''''''
	87888	+ state.addr = 18446744073709546004LLU; // 99999998mT'''''''''''''''
87578	87889	break;
87579	87890	}
87580		- case 18446744073709546019LLU: // 99999998mh'''''''''''''''
	87891	+ case 18446744073709546004LLU: // 99999998mT'''''''''''''''
87581	87892	{
87582	87893	{
87583	87894	uint64_t arg = 0;

		@@ -87656,7 +87967,7 @@
87656	87967	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87657	87968	}
87658	87969	// ACCUMULATE ARGUMENTS - END
87659		- uint64_t return_to = 18446744073709546016LLU;
	87970	+ uint64_t return_to = 18446744073709546001LLU;
87660	87971	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
87661	87972	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87662	87973	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87665,12 +87976,12 @@
87665	87976	state.addr = 787472342492567585LLU; // procvarref
87666	87977	break;
87667	87978	}
87668		- case 18446744073709546016LLU: // 99999998me'''''''''''''''
	87979	+ case 18446744073709546001LLU: // 99999998mQ'''''''''''''''
87669	87980	{
87670		- state.addr = 18446744073709546017LLU; // 99999998mf'''''''''''''''
	87981	+ state.addr = 18446744073709546002LLU; // 99999998mR'''''''''''''''
87671	87982	break;
87672	87983	}
87673		- case 18446744073709546017LLU: // 99999998mf'''''''''''''''
	87984	+ case 18446744073709546002LLU: // 99999998mR'''''''''''''''
87674	87985	{
87675	87986	// variable u64 initialize goes out of scope
87676	87987	// emitted destructur for type u64

		@@ -87681,10 +87992,10 @@
87681	87992	// variable u64 idx_______ goes out of scope
87682	87993	// emitted destructur for type u64
87683	87994	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
87684		- state.addr = 18446744073709546024LLU; // 99999998mm'''''''''''''''
	87995	+ state.addr = 18446744073709546009LLU; // 99999998mY'''''''''''''''
87685	87996	break;
87686	87997	}
87687		- case 18446744073709546024LLU: // 99999998mm'''''''''''''''
	87998	+ case 18446744073709546009LLU: // 99999998mY'''''''''''''''
87688	87999	{
87689	88000	fprintf(stdout, "%s", ");");
87690	88001	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -87693,7 +88004,7 @@
87693	88004	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87694	88005	}
87695	88006	// ACCUMULATE ARGUMENTS - END
87696		- uint64_t return_to = 18446744073709546014LLU;
	88007	+ uint64_t return_to = 18446744073709545999LLU;
87697	88008	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87698	88009	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87699	88010	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87702,12 +88013,12 @@
87702	88013	state.addr = 839519719621918720LLU; // skipws____
87703	88014	break;
87704	88015	}
87705		- case 18446744073709546014LLU: // 99999998mc'''''''''''''''
	88016	+ case 18446744073709545999LLU: // 99999998mO'''''''''''''''
87706	88017	{
87707		- state.addr = 18446744073709546015LLU; // 99999998md'''''''''''''''
	88018	+ state.addr = 18446744073709546000LLU; // 99999998mP'''''''''''''''
87708	88019	break;
87709	88020	}
87710		- case 18446744073709546015LLU: // 99999998md'''''''''''''''
	88021	+ case 18446744073709546000LLU: // 99999998mP'''''''''''''''
87711	88022	{
87712	88023	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
87713	88024	if(')' != (char)getchar())

		@@ -87725,7 +88036,7 @@
87725	88036	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87726	88037	}
87727	88038	// ACCUMULATE ARGUMENTS - END
87728		- uint64_t return_to = 18446744073709546012LLU;
	88039	+ uint64_t return_to = 18446744073709545997LLU;
87729	88040	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
87730	88041	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87731	88042	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87734,12 +88045,12 @@
87734	88045	state.addr = 517555565476695680LLU; // assertu64_
87735	88046	break;
87736	88047	}
87737		- case 18446744073709546012LLU: // 99999998ma'''''''''''''''
	88048	+ case 18446744073709545997LLU: // 99999998mM'''''''''''''''
87738	88049	{
87739		- state.addr = 18446744073709546013LLU; // 99999998mb'''''''''''''''
	88050	+ state.addr = 18446744073709545998LLU; // 99999998mN'''''''''''''''
87740	88051	break;
87741	88052	}
87742		- case 18446744073709546013LLU: // 99999998mb'''''''''''''''
	88053	+ case 18446744073709545998LLU: // 99999998mN'''''''''''''''
87743	88054	{
87744	88055	// variable u64 mutable___ goes out of scope
87745	88056	// emitted destructur for type u64

		@@ -87752,7 +88063,7 @@
87752	88063	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87753	88064	}
87754	88065	// ACCUMULATE ARGUMENTS - END
87755		- uint64_t return_to = 18446744073709546011LLU;
	88066	+ uint64_t return_to = 18446744073709545996LLU;
87756	88067	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87757	88068	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87758	88069	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87761,7 +88072,7 @@
87761	88072	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
87762	88073	break;
87763	88074	}
87764		- case 18446744073709546011LLU: // 99999998m$'''''''''''''''
	88075	+ case 18446744073709545996LLU: // 99999998mL'''''''''''''''
87765	88076	{
87766	88077	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
87767	88078	// variable u64 INDIRECT__ goes out of scope

		@@ -87772,34 +88083,34 @@
87772	88083	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
87773	88084	heap.availilable_size_for_dynamic_objects += 0LLU;
87774	88085	heap.availilable_size_for_dynamic_objects += 0LLU;
87775		- state.addr = 18446744073709546010LLU; // 99999998mZ'''''''''''''''
	88086	+ state.addr = 18446744073709545995LLU; // 99999998mK'''''''''''''''
87776	88087	break;
87777	88088	}
87778		- case 18446744073709546029LLU: // 99999998mr'''''''''''''''
	88089	+ case 18446744073709546014LLU: // 99999998mc'''''''''''''''
87779	88090	{
87780	88091
87781		- state.addr = 18446744073709546009LLU; // 99999998mY'''''''''''''''
	88092	+ state.addr = 18446744073709545994LLU; // 99999998mJ'''''''''''''''
87782	88093	break;
87783	88094	}
87784		- case 18446744073709546009LLU: // 99999998mY'''''''''''''''
	88095	+ case 18446744073709545994LLU: // 99999998mJ'''''''''''''''
87785	88096	{
87786	88097	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 660190761781821440;
87787	88098
87788		- state.addr = 18446744073709546008LLU; // 99999998mX'''''''''''''''
	88099	+ state.addr = 18446744073709545993LLU; // 99999998mI'''''''''''''''
87789	88100	break;
87790	88101	}
87791		- case 18446744073709546008LLU: // 99999998mX'''''''''''''''
	88102	+ case 18446744073709545993LLU: // 99999998mI'''''''''''''''
87792	88103	{
87793	88104	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));
87794		- state.addr = 18446744073709546007LLU; // 99999998mW'''''''''''''''
	88105	+ state.addr = 18446744073709545992LLU; // 99999998mH'''''''''''''''
87795	88106	break;
87796	88107	}
87797		- case 18446744073709546007LLU: // 99999998mW'''''''''''''''
	88108	+ case 18446744073709545992LLU: // 99999998mH'''''''''''''''
87798	88109	{
87799		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546006LLU : 18446744073709546005LLU;
	88110	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545991LLU : 18446744073709545990LLU;
87800	88111	break;
87801	88112	}
87802		- case 18446744073709546006LLU: // 99999998mV'''''''''''''''
	88113	+ case 18446744073709545991LLU: // 99999998mG'''''''''''''''
87803	88114	{
87804	88115	{
87805	88116	uint64_t arg = 0;

		@@ -87821,7 +88132,7 @@
87821	88132	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87822	88133	}
87823	88134	// ACCUMULATE ARGUMENTS - END
87824		- uint64_t return_to = 18446744073709546003LLU;
	88135	+ uint64_t return_to = 18446744073709545988LLU;
87825	88136	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87826	88137	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87827	88138	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87830,12 +88141,12 @@
87830	88141	state.addr = 861504796319285248LLU; // typeu64___
87831	88142	break;
87832	88143	}
87833		- case 18446744073709546003LLU: // 99999998mS'''''''''''''''
	88144	+ case 18446744073709545988LLU: // 99999998mD'''''''''''''''
87834	88145	{
87835		- state.addr = 18446744073709546004LLU; // 99999998mT'''''''''''''''
	88146	+ state.addr = 18446744073709545989LLU; // 99999998mE'''''''''''''''
87836	88147	break;
87837	88148	}
87838		- case 18446744073709546004LLU: // 99999998mT'''''''''''''''
	88149	+ case 18446744073709545989LLU: // 99999998mE'''''''''''''''
87839	88150	{
87840	88151	// ACCUMULATE ARGUMENTS - BEGIN
87841	88152	{

		@@ -87843,7 +88154,7 @@
87843	88154	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87844	88155	}
87845	88156	// ACCUMULATE ARGUMENTS - END
87846		- uint64_t return_to = 18446744073709546001LLU;
	88157	+ uint64_t return_to = 18446744073709545986LLU;
87847	88158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87848	88159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87849	88160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87852,12 +88163,12 @@
87852	88163	state.addr = 839519719621918720LLU; // skipws____
87853	88164	break;
87854	88165	}
87855		- case 18446744073709546001LLU: // 99999998mQ'''''''''''''''
	88166	+ case 18446744073709545986LLU: // 99999998mB'''''''''''''''
87856	88167	{
87857		- state.addr = 18446744073709546002LLU; // 99999998mR'''''''''''''''
	88168	+ state.addr = 18446744073709545987LLU; // 99999998mC'''''''''''''''
87858	88169	break;
87859	88170	}
87860		- case 18446744073709546002LLU: // 99999998mR'''''''''''''''
	88171	+ case 18446744073709545987LLU: // 99999998mC'''''''''''''''
87861	88172	{
87862	88173	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
87863	88174	fprintf(stdout, "%s", "\n ++");

		@@ -87872,7 +88183,7 @@
87872	88183	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87873	88184	}
87874	88185	// ACCUMULATE ARGUMENTS - END
87875		- uint64_t return_to = 18446744073709545998LLU;
	88186	+ uint64_t return_to = 18446744073709545983LLU;
87876	88187	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
87877	88188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87878	88189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87881,24 +88192,24 @@
87881	88192	state.addr = 839519719621918720LLU; // skipws____
87882	88193	break;
87883	88194	}
87884		- case 18446744073709545998LLU: // 99999998mN'''''''''''''''
	88195	+ case 18446744073709545983LLU: // 99999998l9'''''''''''''''
87885	88196	{
87886		- state.addr = 18446744073709545999LLU; // 99999998mO'''''''''''''''
	88197	+ state.addr = 18446744073709545984LLU; // 99999998m_'''''''''''''''
87887	88198	break;
87888	88199	}
87889		- case 18446744073709545999LLU: // 99999998mO'''''''''''''''
	88200	+ case 18446744073709545984LLU: // 99999998m_'''''''''''''''
87890	88201	{
87891	88202
87892		- state.addr = 18446744073709545997LLU; // 99999998mM'''''''''''''''
	88203	+ state.addr = 18446744073709545982LLU; // 99999998l8'''''''''''''''
87893	88204	break;
87894	88205	}
87895		- case 18446744073709545997LLU: // 99999998mM'''''''''''''''
	88206	+ case 18446744073709545982LLU: // 99999998l8'''''''''''''''
87896	88207	{
87897	88208	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
87898		- state.addr = 18446744073709545996LLU; // 99999998mL'''''''''''''''
	88209	+ state.addr = 18446744073709545981LLU; // 99999998l7'''''''''''''''
87899	88210	break;
87900	88211	}
87901		- case 18446744073709545996LLU: // 99999998mL'''''''''''''''
	88212	+ case 18446744073709545981LLU: // 99999998l7'''''''''''''''
87902	88213	{
87903	88214	// ACCUMULATE ARGUMENTS - BEGIN
87904	88215	{

		@@ -87918,7 +88229,7 @@
87918	88229	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
87919	88230	}
87920	88231	// ACCUMULATE ARGUMENTS - END
87921		- uint64_t return_to = 18446744073709545994LLU;
	88232	+ uint64_t return_to = 18446744073709545979LLU;
87922	88233	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
87923	88234	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
87924	88235	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -87927,12 +88238,12 @@
87927	88238	state.addr = 517555565473470767LLU; // assertinit
87928	88239	break;
87929	88240	}
87930		- case 18446744073709545994LLU: // 99999998mJ'''''''''''''''
	88241	+ case 18446744073709545979LLU: // 99999998l5'''''''''''''''
87931	88242	{
87932		- state.addr = 18446744073709545995LLU; // 99999998mK'''''''''''''''
	88243	+ state.addr = 18446744073709545980LLU; // 99999998l6'''''''''''''''
87933	88244	break;
87934	88245	}
87935		- case 18446744073709545995LLU: // 99999998mK'''''''''''''''
	88246	+ case 18446744073709545980LLU: // 99999998l6'''''''''''''''
87936	88247	{
87937	88248	{
87938	88249	uint64_t arg = 0;

		@@ -88011,7 +88322,7 @@
88011	88322	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88012	88323	}
88013	88324	// ACCUMULATE ARGUMENTS - END
88014		- uint64_t return_to = 18446744073709545992LLU;
	88325	+ uint64_t return_to = 18446744073709545977LLU;
88015	88326	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
88016	88327	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88017	88328	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88020,12 +88331,12 @@
88020	88331	state.addr = 787472342492567585LLU; // procvarref
88021	88332	break;
88022	88333	}
88023		- case 18446744073709545992LLU: // 99999998mH'''''''''''''''
	88334	+ case 18446744073709545977LLU: // 99999998l3'''''''''''''''
88024	88335	{
88025		- state.addr = 18446744073709545993LLU; // 99999998mI'''''''''''''''
	88336	+ state.addr = 18446744073709545978LLU; // 99999998l4'''''''''''''''
88026	88337	break;
88027	88338	}
88028		- case 18446744073709545993LLU: // 99999998mI'''''''''''''''
	88339	+ case 18446744073709545978LLU: // 99999998l4'''''''''''''''
88029	88340	{
88030	88341	// variable u64 initialize goes out of scope
88031	88342	// emitted destructur for type u64

		@@ -88036,10 +88347,10 @@
88036	88347	// variable u64 idx_______ goes out of scope
88037	88348	// emitted destructur for type u64
88038	88349	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
88039		- state.addr = 18446744073709546000LLU; // 99999998mP'''''''''''''''
	88350	+ state.addr = 18446744073709545985LLU; // 99999998mA'''''''''''''''
88040	88351	break;
88041	88352	}
88042		- case 18446744073709546000LLU: // 99999998mP'''''''''''''''
	88353	+ case 18446744073709545985LLU: // 99999998mA'''''''''''''''
88043	88354	{
88044	88355	fprintf(stdout, "%s", ";");
88045	88356	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -88048,7 +88359,7 @@
88048	88359	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88049	88360	}
88050	88361	// ACCUMULATE ARGUMENTS - END
88051		- uint64_t return_to = 18446744073709545990LLU;
	88362	+ uint64_t return_to = 18446744073709545975LLU;
88052	88363	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88053	88364	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88054	88365	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88057,12 +88368,12 @@
88057	88368	state.addr = 839519719621918720LLU; // skipws____
88058	88369	break;
88059	88370	}
88060		- case 18446744073709545990LLU: // 99999998mF'''''''''''''''
	88371	+ case 18446744073709545975LLU: // 99999998l1'''''''''''''''
88061	88372	{
88062		- state.addr = 18446744073709545991LLU; // 99999998mG'''''''''''''''
	88373	+ state.addr = 18446744073709545976LLU; // 99999998l2'''''''''''''''
88063	88374	break;
88064	88375	}
88065		- case 18446744073709545991LLU: // 99999998mG'''''''''''''''
	88376	+ case 18446744073709545976LLU: // 99999998l2'''''''''''''''
88066	88377	{
88067	88378	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
88068	88379	if(')' != (char)getchar())

		@@ -88080,7 +88391,7 @@
88080	88391	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88081	88392	}
88082	88393	// ACCUMULATE ARGUMENTS - END
88083		- uint64_t return_to = 18446744073709545988LLU;
	88394	+ uint64_t return_to = 18446744073709545973LLU;
88084	88395	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
88085	88396	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88086	88397	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88089,12 +88400,12 @@
88089	88400	state.addr = 517555565476695680LLU; // assertu64_
88090	88401	break;
88091	88402	}
88092		- case 18446744073709545988LLU: // 99999998mD'''''''''''''''
	88403	+ case 18446744073709545973LLU: // 99999998lz'''''''''''''''
88093	88404	{
88094		- state.addr = 18446744073709545989LLU; // 99999998mE'''''''''''''''
	88405	+ state.addr = 18446744073709545974LLU; // 99999998l0'''''''''''''''
88095	88406	break;
88096	88407	}
88097		- case 18446744073709545989LLU: // 99999998mE'''''''''''''''
	88408	+ case 18446744073709545974LLU: // 99999998l0'''''''''''''''
88098	88409	{
88099	88410	{
88100	88411	uint64_t arg = 0;

		@@ -88123,7 +88434,7 @@
88123	88434	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88124	88435	}
88125	88436	// ACCUMULATE ARGUMENTS - END
88126		- uint64_t return_to = 18446744073709545985LLU;
	88437	+ uint64_t return_to = 18446744073709545970LLU;
88127	88438	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
88128	88439	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88129	88440	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88132,20 +88443,20 @@
88132	88443	state.addr = 734295421765213120LLU; // mutassert_
88133	88444	break;
88134	88445	}
88135		- case 18446744073709545985LLU: // 99999998mA'''''''''''''''
	88446	+ case 18446744073709545970LLU: // 99999998lw'''''''''''''''
88136	88447	{
88137		- state.addr = 18446744073709545986LLU; // 99999998mB'''''''''''''''
	88448	+ state.addr = 18446744073709545971LLU; // 99999998lx'''''''''''''''
88138	88449	break;
88139	88450	}
88140		- case 18446744073709545986LLU: // 99999998mB'''''''''''''''
	88451	+ case 18446744073709545971LLU: // 99999998lx'''''''''''''''
88141	88452	{
88142	88453	// variable u64 parnr_____ goes out of scope
88143	88454	// emitted destructur for type u64
88144	88455	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
88145		- state.addr = 18446744073709545987LLU; // 99999998mC'''''''''''''''
	88456	+ state.addr = 18446744073709545972LLU; // 99999998ly'''''''''''''''
88146	88457	break;
88147	88458	}
88148		- case 18446744073709545987LLU: // 99999998mC'''''''''''''''
	88459	+ case 18446744073709545972LLU: // 99999998ly'''''''''''''''
88149	88460	{
88150	88461	// variable u64 mutable___ goes out of scope
88151	88462	// emitted destructur for type u64

		@@ -88158,7 +88469,7 @@
88158	88469	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88159	88470	}
88160	88471	// ACCUMULATE ARGUMENTS - END
88161		- uint64_t return_to = 18446744073709545984LLU;
	88472	+ uint64_t return_to = 18446744073709545969LLU;
88162	88473	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88163	88474	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88164	88475	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88167,7 +88478,7 @@
88167	88478	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
88168	88479	break;
88169	88480	}
88170		- case 18446744073709545984LLU: // 99999998m_'''''''''''''''
	88481	+ case 18446744073709545969LLU: // 99999998lv'''''''''''''''
88171	88482	{
88172	88483	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
88173	88484	// variable u64 INDIRECT__ goes out of scope

		@@ -88178,34 +88489,34 @@
88178	88489	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
88179	88490	heap.availilable_size_for_dynamic_objects += 0LLU;
88180	88491	heap.availilable_size_for_dynamic_objects += 0LLU;
88181		- state.addr = 18446744073709545983LLU; // 99999998l9'''''''''''''''
	88492	+ state.addr = 18446744073709545968LLU; // 99999998lu'''''''''''''''
88182	88493	break;
88183	88494	}
88184		- case 18446744073709546005LLU: // 99999998mU'''''''''''''''
	88495	+ case 18446744073709545990LLU: // 99999998mF'''''''''''''''
88185	88496	{
88186	88497
88187		- state.addr = 18446744073709545982LLU; // 99999998l8'''''''''''''''
	88498	+ state.addr = 18446744073709545967LLU; // 99999998lt'''''''''''''''
88188	88499	break;
88189	88500	}
88190		- case 18446744073709545982LLU: // 99999998l8'''''''''''''''
	88501	+ case 18446744073709545967LLU: // 99999998lt'''''''''''''''
88191	88502	{
88192	88503	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 567585494444015616;
88193	88504
88194		- state.addr = 18446744073709545981LLU; // 99999998l7'''''''''''''''
	88505	+ state.addr = 18446744073709545966LLU; // 99999998ls'''''''''''''''
88195	88506	break;
88196	88507	}
88197		- case 18446744073709545981LLU: // 99999998l7'''''''''''''''
	88508	+ case 18446744073709545966LLU: // 99999998ls'''''''''''''''
88198	88509	{
88199	88510	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));
88200		- state.addr = 18446744073709545980LLU; // 99999998l6'''''''''''''''
	88511	+ state.addr = 18446744073709545965LLU; // 99999998lr'''''''''''''''
88201	88512	break;
88202	88513	}
88203		- case 18446744073709545980LLU: // 99999998l6'''''''''''''''
	88514	+ case 18446744073709545965LLU: // 99999998lr'''''''''''''''
88204	88515	{
88205		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545979LLU : 18446744073709545978LLU;
	88516	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545964LLU : 18446744073709545963LLU;
88206	88517	break;
88207	88518	}
88208		- case 18446744073709545979LLU: // 99999998l5'''''''''''''''
	88519	+ case 18446744073709545964LLU: // 99999998lq'''''''''''''''
88209	88520	{
88210	88521	{
88211	88522	uint64_t arg = 0;

		@@ -88227,7 +88538,7 @@
88227	88538	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88228	88539	}
88229	88540	// ACCUMULATE ARGUMENTS - END
88230		- uint64_t return_to = 18446744073709545976LLU;
	88541	+ uint64_t return_to = 18446744073709545961LLU;
88231	88542	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88232	88543	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88233	88544	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88236,12 +88547,12 @@
88236	88547	state.addr = 861504796319285248LLU; // typeu64___
88237	88548	break;
88238	88549	}
88239		- case 18446744073709545976LLU: // 99999998l2'''''''''''''''
	88550	+ case 18446744073709545961LLU: // 99999998ln'''''''''''''''
88240	88551	{
88241		- state.addr = 18446744073709545977LLU; // 99999998l3'''''''''''''''
	88552	+ state.addr = 18446744073709545962LLU; // 99999998lo'''''''''''''''
88242	88553	break;
88243	88554	}
88244		- case 18446744073709545977LLU: // 99999998l3'''''''''''''''
	88555	+ case 18446744073709545962LLU: // 99999998lo'''''''''''''''
88245	88556	{
88246	88557	// ACCUMULATE ARGUMENTS - BEGIN
88247	88558	{

		@@ -88249,7 +88560,7 @@
88249	88560	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88250	88561	}
88251	88562	// ACCUMULATE ARGUMENTS - END
88252		- uint64_t return_to = 18446744073709545974LLU;
	88563	+ uint64_t return_to = 18446744073709545959LLU;
88253	88564	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88254	88565	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88255	88566	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88258,12 +88569,12 @@
88258	88569	state.addr = 839519719621918720LLU; // skipws____
88259	88570	break;
88260	88571	}
88261		- case 18446744073709545974LLU: // 99999998l0'''''''''''''''
	88572	+ case 18446744073709545959LLU: // 99999998ll'''''''''''''''
88262	88573	{
88263		- state.addr = 18446744073709545975LLU; // 99999998l1'''''''''''''''
	88574	+ state.addr = 18446744073709545960LLU; // 99999998lm'''''''''''''''
88264	88575	break;
88265	88576	}
88266		- case 18446744073709545975LLU: // 99999998l1'''''''''''''''
	88577	+ case 18446744073709545960LLU: // 99999998lm'''''''''''''''
88267	88578	{
88268	88579	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
88269	88580	fprintf(stdout, "%s", "\n --");

		@@ -88278,7 +88589,7 @@
88278	88589	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88279	88590	}
88280	88591	// ACCUMULATE ARGUMENTS - END
88281		- uint64_t return_to = 18446744073709545971LLU;
	88592	+ uint64_t return_to = 18446744073709545956LLU;
88282	88593	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88283	88594	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88284	88595	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88287,24 +88598,24 @@
88287	88598	state.addr = 839519719621918720LLU; // skipws____
88288	88599	break;
88289	88600	}
88290		- case 18446744073709545971LLU: // 99999998lx'''''''''''''''
	88601	+ case 18446744073709545956LLU: // 99999998li'''''''''''''''
88291	88602	{
88292		- state.addr = 18446744073709545972LLU; // 99999998ly'''''''''''''''
	88603	+ state.addr = 18446744073709545957LLU; // 99999998lj'''''''''''''''
88293	88604	break;
88294	88605	}
88295		- case 18446744073709545972LLU: // 99999998ly'''''''''''''''
	88606	+ case 18446744073709545957LLU: // 99999998lj'''''''''''''''
88296	88607	{
88297	88608
88298		- state.addr = 18446744073709545970LLU; // 99999998lw'''''''''''''''
	88609	+ state.addr = 18446744073709545955LLU; // 99999998lh'''''''''''''''
88299	88610	break;
88300	88611	}
88301		- case 18446744073709545970LLU: // 99999998lw'''''''''''''''
	88612	+ case 18446744073709545955LLU: // 99999998lh'''''''''''''''
88302	88613	{
88303	88614	LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
88304		- state.addr = 18446744073709545969LLU; // 99999998lv'''''''''''''''
	88615	+ state.addr = 18446744073709545954LLU; // 99999998lg'''''''''''''''
88305	88616	break;
88306	88617	}
88307		- case 18446744073709545969LLU: // 99999998lv'''''''''''''''
	88618	+ case 18446744073709545954LLU: // 99999998lg'''''''''''''''
88308	88619	{
88309	88620	// ACCUMULATE ARGUMENTS - BEGIN
88310	88621	{

		@@ -88324,7 +88635,7 @@
88324	88635	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88325	88636	}
88326	88637	// ACCUMULATE ARGUMENTS - END
88327		- uint64_t return_to = 18446744073709545967LLU;
	88638	+ uint64_t return_to = 18446744073709545952LLU;
88328	88639	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
88329	88640	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88330	88641	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88333,12 +88644,12 @@
88333	88644	state.addr = 517555565473470767LLU; // assertinit
88334	88645	break;
88335	88646	}
88336		- case 18446744073709545967LLU: // 99999998lt'''''''''''''''
	88647	+ case 18446744073709545952LLU: // 99999998le'''''''''''''''
88337	88648	{
88338		- state.addr = 18446744073709545968LLU; // 99999998lu'''''''''''''''
	88649	+ state.addr = 18446744073709545953LLU; // 99999998lf'''''''''''''''
88339	88650	break;
88340	88651	}
88341		- case 18446744073709545968LLU: // 99999998lu'''''''''''''''
	88652	+ case 18446744073709545953LLU: // 99999998lf'''''''''''''''
88342	88653	{
88343	88654	{
88344	88655	uint64_t arg = 0;

		@@ -88417,7 +88728,7 @@
88417	88728	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88418	88729	}
88419	88730	// ACCUMULATE ARGUMENTS - END
88420		- uint64_t return_to = 18446744073709545965LLU;
	88731	+ uint64_t return_to = 18446744073709545950LLU;
88421	88732	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
88422	88733	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88423	88734	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88426,12 +88737,12 @@
88426	88737	state.addr = 787472342492567585LLU; // procvarref
88427	88738	break;
88428	88739	}
88429		- case 18446744073709545965LLU: // 99999998lr'''''''''''''''
	88740	+ case 18446744073709545950LLU: // 99999998lc'''''''''''''''
88430	88741	{
88431		- state.addr = 18446744073709545966LLU; // 99999998ls'''''''''''''''
	88742	+ state.addr = 18446744073709545951LLU; // 99999998ld'''''''''''''''
88432	88743	break;
88433	88744	}
88434		- case 18446744073709545966LLU: // 99999998ls'''''''''''''''
	88745	+ case 18446744073709545951LLU: // 99999998ld'''''''''''''''
88435	88746	{
88436	88747	// variable u64 initialize goes out of scope
88437	88748	// emitted destructur for type u64

		@@ -88442,10 +88753,10 @@
88442	88753	// variable u64 idx_______ goes out of scope
88443	88754	// emitted destructur for type u64
88444	88755	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
88445		- state.addr = 18446744073709545973LLU; // 99999998lz'''''''''''''''
	88756	+ state.addr = 18446744073709545958LLU; // 99999998lk'''''''''''''''
88446	88757	break;
88447	88758	}
88448		- case 18446744073709545973LLU: // 99999998lz'''''''''''''''
	88759	+ case 18446744073709545958LLU: // 99999998lk'''''''''''''''
88449	88760	{
88450	88761	fprintf(stdout, "%s", ";");
88451	88762	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -88454,7 +88765,7 @@
88454	88765	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88455	88766	}
88456	88767	// ACCUMULATE ARGUMENTS - END
88457		- uint64_t return_to = 18446744073709545963LLU;
	88768	+ uint64_t return_to = 18446744073709545948LLU;
88458	88769	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88459	88770	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88460	88771	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88463,12 +88774,12 @@
88463	88774	state.addr = 839519719621918720LLU; // skipws____
88464	88775	break;
88465	88776	}
88466		- case 18446744073709545963LLU: // 99999998lp'''''''''''''''
	88777	+ case 18446744073709545948LLU: // 99999998la'''''''''''''''
88467	88778	{
88468		- state.addr = 18446744073709545964LLU; // 99999998lq'''''''''''''''
	88779	+ state.addr = 18446744073709545949LLU; // 99999998lb'''''''''''''''
88469	88780	break;
88470	88781	}
88471		- case 18446744073709545964LLU: // 99999998lq'''''''''''''''
	88782	+ case 18446744073709545949LLU: // 99999998lb'''''''''''''''
88472	88783	{
88473	88784	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
88474	88785	if(')' != (char)getchar())

		@@ -88486,7 +88797,7 @@
88486	88797	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88487	88798	}
88488	88799	// ACCUMULATE ARGUMENTS - END
88489		- uint64_t return_to = 18446744073709545961LLU;
	88800	+ uint64_t return_to = 18446744073709545946LLU;
88490	88801	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
88491	88802	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88492	88803	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88495,12 +88806,12 @@
88495	88806	state.addr = 517555565476695680LLU; // assertu64_
88496	88807	break;
88497	88808	}
88498		- case 18446744073709545961LLU: // 99999998ln'''''''''''''''
	88809	+ case 18446744073709545946LLU: // 99999998lZ'''''''''''''''
88499	88810	{
88500		- state.addr = 18446744073709545962LLU; // 99999998lo'''''''''''''''
	88811	+ state.addr = 18446744073709545947LLU; // 99999998l$'''''''''''''''
88501	88812	break;
88502	88813	}
88503		- case 18446744073709545962LLU: // 99999998lo'''''''''''''''
	88814	+ case 18446744073709545947LLU: // 99999998l$'''''''''''''''
88504	88815	{
88505	88816	{
88506	88817	uint64_t arg = 0;

		@@ -88529,7 +88840,7 @@
88529	88840	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88530	88841	}
88531	88842	// ACCUMULATE ARGUMENTS - END
88532		- uint64_t return_to = 18446744073709545958LLU;
	88843	+ uint64_t return_to = 18446744073709545943LLU;
88533	88844	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
88534	88845	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88535	88846	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88538,20 +88849,20 @@
88538	88849	state.addr = 734295421765213120LLU; // mutassert_
88539	88850	break;
88540	88851	}
88541		- case 18446744073709545958LLU: // 99999998lk'''''''''''''''
	88852	+ case 18446744073709545943LLU: // 99999998lW'''''''''''''''
88542	88853	{
88543		- state.addr = 18446744073709545959LLU; // 99999998ll'''''''''''''''
	88854	+ state.addr = 18446744073709545944LLU; // 99999998lX'''''''''''''''
88544	88855	break;
88545	88856	}
88546		- case 18446744073709545959LLU: // 99999998ll'''''''''''''''
	88857	+ case 18446744073709545944LLU: // 99999998lX'''''''''''''''
88547	88858	{
88548	88859	// variable u64 parnr_____ goes out of scope
88549	88860	// emitted destructur for type u64
88550	88861	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
88551		- state.addr = 18446744073709545960LLU; // 99999998lm'''''''''''''''
	88862	+ state.addr = 18446744073709545945LLU; // 99999998lY'''''''''''''''
88552	88863	break;
88553	88864	}
88554		- case 18446744073709545960LLU: // 99999998lm'''''''''''''''
	88865	+ case 18446744073709545945LLU: // 99999998lY'''''''''''''''
88555	88866	{
88556	88867	// variable u64 mutable___ goes out of scope
88557	88868	// emitted destructur for type u64

		@@ -88564,7 +88875,7 @@
88564	88875	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88565	88876	}
88566	88877	// ACCUMULATE ARGUMENTS - END
88567		- uint64_t return_to = 18446744073709545957LLU;
	88878	+ uint64_t return_to = 18446744073709545942LLU;
88568	88879	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88569	88880	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88570	88881	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88573,7 +88884,7 @@
88573	88884	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
88574	88885	break;
88575	88886	}
88576		- case 18446744073709545957LLU: // 99999998lj'''''''''''''''
	88887	+ case 18446744073709545942LLU: // 99999998lV'''''''''''''''
88577	88888	{
88578	88889	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
88579	88890	// variable u64 INDIRECT__ goes out of scope

		@@ -88584,40 +88895,40 @@
88584	88895	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
88585	88896	heap.availilable_size_for_dynamic_objects += 0LLU;
88586	88897	heap.availilable_size_for_dynamic_objects += 0LLU;
88587		- state.addr = 18446744073709545956LLU; // 99999998li'''''''''''''''
	88898	+ state.addr = 18446744073709545941LLU; // 99999998lU'''''''''''''''
88588	88899	break;
88589	88900	}
88590		- case 18446744073709545978LLU: // 99999998l4'''''''''''''''
	88901	+ case 18446744073709545963LLU: // 99999998lp'''''''''''''''
88591	88902	{
88592		- state.addr = 18446744073709545956LLU; // 99999998li'''''''''''''''
	88903	+ state.addr = 18446744073709545941LLU; // 99999998lU'''''''''''''''
88593	88904	break;
88594	88905	}
88595		- case 18446744073709545956LLU: // 99999998li'''''''''''''''
	88906	+ case 18446744073709545941LLU: // 99999998lU'''''''''''''''
88596	88907	{
88597		- state.addr = 18446744073709545983LLU; // 99999998l9'''''''''''''''
	88908	+ state.addr = 18446744073709545968LLU; // 99999998lu'''''''''''''''
88598	88909	break;
88599	88910	}
88600		- case 18446744073709545983LLU: // 99999998l9'''''''''''''''
	88911	+ case 18446744073709545968LLU: // 99999998lu'''''''''''''''
88601	88912	{
88602		- state.addr = 18446744073709546010LLU; // 99999998mZ'''''''''''''''
	88913	+ state.addr = 18446744073709545995LLU; // 99999998mK'''''''''''''''
88603	88914	break;
88604	88915	}
88605		- case 18446744073709546010LLU: // 99999998mZ'''''''''''''''
	88916	+ case 18446744073709545995LLU: // 99999998mK'''''''''''''''
88606	88917	{
88607		- state.addr = 18446744073709546034LLU; // 99999998mw'''''''''''''''
	88918	+ state.addr = 18446744073709546019LLU; // 99999998mh'''''''''''''''
88608	88919	break;
88609	88920	}
88610		- case 18446744073709546034LLU: // 99999998mw'''''''''''''''
	88921	+ case 18446744073709546019LLU: // 99999998mh'''''''''''''''
88611	88922	{
88612		- state.addr = 18446744073709546058LLU; // 99999998nJ'''''''''''''''
	88923	+ state.addr = 18446744073709546043LLU; // 99999998m5'''''''''''''''
88613	88924	break;
88614	88925	}
88615		- case 18446744073709546058LLU: // 99999998nJ'''''''''''''''
	88926	+ case 18446744073709546043LLU: // 99999998m5'''''''''''''''
88616	88927	{
88617		- state.addr = 18446744073709546082LLU; // 99999998ng'''''''''''''''
	88928	+ state.addr = 18446744073709546067LLU; // 99999998nS'''''''''''''''
88618	88929	break;
88619	88930	}
88620		- case 18446744073709546082LLU: // 99999998ng'''''''''''''''
	88931	+ case 18446744073709546067LLU: // 99999998nS'''''''''''''''
88621	88932	{
88622	88933	// variable u64 sym_______ goes out of scope
88623	88934	// emitted destructur for type u64

		@@ -88742,28 +89053,28 @@
88742	89053	}
88743	89054	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 0;
88744	89055
88745		- state.addr = 18446744073709545955LLU; // 99999998lh'''''''''''''''
	89056	+ state.addr = 18446744073709545940LLU; // 99999998lT'''''''''''''''
88746	89057	break;
88747	89058	}
88748		- case 18446744073709545955LLU: // 99999998lh'''''''''''''''
	89059	+ case 18446744073709545940LLU: // 99999998lT'''''''''''''''
88749	89060	{
88750	89061	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 552467879098960576;
88751	89062
88752		- state.addr = 18446744073709545954LLU; // 99999998lg'''''''''''''''
	89063	+ state.addr = 18446744073709545939LLU; // 99999998lS'''''''''''''''
88753	89064	break;
88754	89065	}
88755		- case 18446744073709545954LLU: // 99999998lg'''''''''''''''
	89066	+ case 18446744073709545939LLU: // 99999998lS'''''''''''''''
88756	89067	{
88757	89068	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
88758		- state.addr = 18446744073709545953LLU; // 99999998lf'''''''''''''''
	89069	+ state.addr = 18446744073709545938LLU; // 99999998lR'''''''''''''''
88759	89070	break;
88760	89071	}
88761		- case 18446744073709545953LLU: // 99999998lf'''''''''''''''
	89072	+ case 18446744073709545938LLU: // 99999998lR'''''''''''''''
88762	89073	{
88763		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545952LLU : 18446744073709545951LLU;
	89074	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545937LLU : 18446744073709545936LLU;
88764	89075	break;
88765	89076	}
88766		- case 18446744073709545952LLU: // 99999998le'''''''''''''''
	89077	+ case 18446744073709545937LLU: // 99999998lQ'''''''''''''''
88767	89078	{
88768	89079	// ACCUMULATE ARGUMENTS - BEGIN
88769	89080	{

		@@ -88771,7 +89082,7 @@
88771	89082	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88772	89083	}
88773	89084	// ACCUMULATE ARGUMENTS - END
88774		- uint64_t return_to = 18446744073709545949LLU;
	89085	+ uint64_t return_to = 18446744073709545934LLU;
88775	89086	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88776	89087	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88777	89088	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88780,12 +89091,12 @@
88780	89091	state.addr = 839519719621918720LLU; // skipws____
88781	89092	break;
88782	89093	}
88783		- case 18446744073709545949LLU: // 99999998lb'''''''''''''''
	89094	+ case 18446744073709545934LLU: // 99999998lN'''''''''''''''
88784	89095	{
88785		- state.addr = 18446744073709545950LLU; // 99999998lc'''''''''''''''
	89096	+ state.addr = 18446744073709545935LLU; // 99999998lO'''''''''''''''
88786	89097	break;
88787	89098	}
88788		- case 18446744073709545950LLU: // 99999998lc'''''''''''''''
	89099	+ case 18446744073709545935LLU: // 99999998lO'''''''''''''''
88789	89100	{
88790	89101	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
88791	89102	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -88794,7 +89105,7 @@
88794	89105	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88795	89106	}
88796	89107	// ACCUMULATE ARGUMENTS - END
88797		- uint64_t return_to = 18446744073709545947LLU;
	89108	+ uint64_t return_to = 18446744073709545932LLU;
88798	89109	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
88799	89110	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88800	89111	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88803,45 +89114,45 @@
88803	89114	state.addr = 839519719621918720LLU; // skipws____
88804	89115	break;
88805	89116	}
88806		- case 18446744073709545947LLU: // 99999998l$'''''''''''''''
	89117	+ case 18446744073709545932LLU: // 99999998lL'''''''''''''''
88807	89118	{
88808		- state.addr = 18446744073709545948LLU; // 99999998la'''''''''''''''
	89119	+ state.addr = 18446744073709545933LLU; // 99999998lM'''''''''''''''
88809	89120	break;
88810	89121	}
88811		- case 18446744073709545948LLU: // 99999998la'''''''''''''''
	89122	+ case 18446744073709545933LLU: // 99999998lM'''''''''''''''
88812	89123	{
88813	89124	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
88814	89125	fprintf(stdout, "%s", "fprintf(stderr, \"HEAPSIZE: %llu\\n\", (unsigned long long)countheap(&heap));\n");
88815	89126	heap.availilable_size_for_dynamic_objects += 0LLU;
88816	89127	heap.availilable_size_for_dynamic_objects += 0LLU;
88817		- state.addr = 18446744073709545946LLU; // 99999998lZ'''''''''''''''
	89128	+ state.addr = 18446744073709545931LLU; // 99999998lK'''''''''''''''
88818	89129	break;
88819	89130	}
88820		- case 18446744073709545951LLU: // 99999998ld'''''''''''''''
	89131	+ case 18446744073709545936LLU: // 99999998lP'''''''''''''''
88821	89132	{
88822	89133
88823		- state.addr = 18446744073709545945LLU; // 99999998lY'''''''''''''''
	89134	+ state.addr = 18446744073709545930LLU; // 99999998lJ'''''''''''''''
88824	89135	break;
88825	89136	}
88826		- case 18446744073709545945LLU: // 99999998lY'''''''''''''''
	89137	+ case 18446744073709545930LLU: // 99999998lJ'''''''''''''''
88827	89138	{
88828	89139	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 589327972884807680;
88829	89140
88830		- state.addr = 18446744073709545944LLU; // 99999998lX'''''''''''''''
	89141	+ state.addr = 18446744073709545929LLU; // 99999998lI'''''''''''''''
88831	89142	break;
88832	89143	}
88833		- case 18446744073709545944LLU: // 99999998lX'''''''''''''''
	89144	+ case 18446744073709545929LLU: // 99999998lI'''''''''''''''
88834	89145	{
88835	89146	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
88836		- state.addr = 18446744073709545943LLU; // 99999998lW'''''''''''''''
	89147	+ state.addr = 18446744073709545928LLU; // 99999998lH'''''''''''''''
88837	89148	break;
88838	89149	}
88839		- case 18446744073709545943LLU: // 99999998lW'''''''''''''''
	89150	+ case 18446744073709545928LLU: // 99999998lH'''''''''''''''
88840	89151	{
88841		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545942LLU : 18446744073709545941LLU;
	89152	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545927LLU : 18446744073709545926LLU;
88842	89153	break;
88843	89154	}
88844		- case 18446744073709545942LLU: // 99999998lV'''''''''''''''
	89155	+ case 18446744073709545927LLU: // 99999998lG'''''''''''''''
88845	89156	{
88846	89157	// ACCUMULATE ARGUMENTS - BEGIN
88847	89158	{

		@@ -88857,7 +89168,7 @@
88857	89168	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88858	89169	}
88859	89170	// ACCUMULATE ARGUMENTS - END
88860		- uint64_t return_to = 18446744073709545939LLU;
	89171	+ uint64_t return_to = 18446744073709545924LLU;
88861	89172	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
88862	89173	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88863	89174	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88866,43 +89177,43 @@
88866	89177	state.addr = 787472324524157760LLU; // procerror_
88867	89178	break;
88868	89179	}
88869		- case 18446744073709545939LLU: // 99999998lS'''''''''''''''
	89180	+ case 18446744073709545924LLU: // 99999998lD'''''''''''''''
88870	89181	{
88871		- state.addr = 18446744073709545940LLU; // 99999998lT'''''''''''''''
	89182	+ state.addr = 18446744073709545925LLU; // 99999998lE'''''''''''''''
88872	89183	break;
88873	89184	}
88874		- case 18446744073709545940LLU: // 99999998lT'''''''''''''''
	89185	+ case 18446744073709545925LLU: // 99999998lE'''''''''''''''
88875	89186	{
88876	89187	heap.availilable_size_for_dynamic_objects += 0LLU;
88877	89188	heap.availilable_size_for_dynamic_objects += 0LLU;
88878		- state.addr = 18446744073709545938LLU; // 99999998lR'''''''''''''''
	89189	+ state.addr = 18446744073709545923LLU; // 99999998lC'''''''''''''''
88879	89190	break;
88880	89191	}
88881		- case 18446744073709545941LLU: // 99999998lU'''''''''''''''
	89192	+ case 18446744073709545926LLU: // 99999998lF'''''''''''''''
88882	89193	{
88883	89194
88884		- state.addr = 18446744073709545937LLU; // 99999998lQ'''''''''''''''
	89195	+ state.addr = 18446744073709545922LLU; // 99999998lB'''''''''''''''
88885	89196	break;
88886	89197	}
88887		- case 18446744073709545937LLU: // 99999998lQ'''''''''''''''
	89198	+ case 18446744073709545922LLU: // 99999998lB'''''''''''''''
88888	89199	{
88889	89200	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 819847183506341888;
88890	89201
88891		- state.addr = 18446744073709545936LLU; // 99999998lP'''''''''''''''
	89202	+ state.addr = 18446744073709545921LLU; // 99999998lA'''''''''''''''
88892	89203	break;
88893	89204	}
88894		- case 18446744073709545936LLU: // 99999998lP'''''''''''''''
	89205	+ case 18446744073709545921LLU: // 99999998lA'''''''''''''''
88895	89206	{
88896	89207	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
88897		- state.addr = 18446744073709545935LLU; // 99999998lO'''''''''''''''
	89208	+ state.addr = 18446744073709545920LLU; // 99999998l_'''''''''''''''
88898	89209	break;
88899	89210	}
88900		- case 18446744073709545935LLU: // 99999998lO'''''''''''''''
	89211	+ case 18446744073709545920LLU: // 99999998l_'''''''''''''''
88901	89212	{
88902		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545934LLU : 18446744073709545933LLU;
	89213	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545919LLU : 18446744073709545918LLU;
88903	89214	break;
88904	89215	}
88905		- case 18446744073709545934LLU: // 99999998lN'''''''''''''''
	89216	+ case 18446744073709545919LLU: // 99999998k9'''''''''''''''
88906	89217	{
88907	89218	// ACCUMULATE ARGUMENTS - BEGIN
88908	89219	{

		@@ -88938,7 +89249,7 @@
88938	89249	LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
88939	89250	}
88940	89251	// ACCUMULATE ARGUMENTS - END
88941		- uint64_t return_to = 18446744073709545931LLU;
	89252	+ uint64_t return_to = 18446744073709545916LLU;
88942	89253	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0));
88943	89254	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
88944	89255	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -88947,43 +89258,43 @@
88947	89258	state.addr = 787472338264173423LLU; // procreport
88948	89259	break;
88949	89260	}
88950		- case 18446744073709545931LLU: // 99999998lK'''''''''''''''
	89261	+ case 18446744073709545916LLU: // 99999998k6'''''''''''''''
88951	89262	{
88952		- state.addr = 18446744073709545932LLU; // 99999998lL'''''''''''''''
	89263	+ state.addr = 18446744073709545917LLU; // 99999998k7'''''''''''''''
88953	89264	break;
88954	89265	}
88955		- case 18446744073709545932LLU: // 99999998lL'''''''''''''''
	89266	+ case 18446744073709545917LLU: // 99999998k7'''''''''''''''
88956	89267	{
88957	89268	heap.availilable_size_for_dynamic_objects += 0LLU;
88958	89269	heap.availilable_size_for_dynamic_objects += 0LLU;
88959		- state.addr = 18446744073709545930LLU; // 99999998lJ'''''''''''''''
	89270	+ state.addr = 18446744073709545915LLU; // 99999998k5'''''''''''''''
88960	89271	break;
88961	89272	}
88962		- case 18446744073709545933LLU: // 99999998lM'''''''''''''''
	89273	+ case 18446744073709545918LLU: // 99999998k8'''''''''''''''
88963	89274	{
88964	89275
88965		- state.addr = 18446744073709545929LLU; // 99999998lI'''''''''''''''
	89276	+ state.addr = 18446744073709545914LLU; // 99999998k4'''''''''''''''
88966	89277	break;
88967	89278	}
88968		- case 18446744073709545929LLU: // 99999998lI'''''''''''''''
	89279	+ case 18446744073709545914LLU: // 99999998k4'''''''''''''''
88969	89280	{
88970	89281	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 787446707498516480;
88971	89282
88972		- state.addr = 18446744073709545928LLU; // 99999998lH'''''''''''''''
	89283	+ state.addr = 18446744073709545913LLU; // 99999998k3'''''''''''''''
88973	89284	break;
88974	89285	}
88975		- case 18446744073709545928LLU: // 99999998lH'''''''''''''''
	89286	+ case 18446744073709545913LLU: // 99999998k3'''''''''''''''
88976	89287	{
88977	89288	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
88978		- state.addr = 18446744073709545927LLU; // 99999998lG'''''''''''''''
	89289	+ state.addr = 18446744073709545912LLU; // 99999998k2'''''''''''''''
88979	89290	break;
88980	89291	}
88981		- case 18446744073709545927LLU: // 99999998lG'''''''''''''''
	89292	+ case 18446744073709545912LLU: // 99999998k2'''''''''''''''
88982	89293	{
88983		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545926LLU : 18446744073709545925LLU;
	89294	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545911LLU : 18446744073709545910LLU;
88984	89295	break;
88985	89296	}
88986		- case 18446744073709545926LLU: // 99999998lF'''''''''''''''
	89297	+ case 18446744073709545911LLU: // 99999998k1'''''''''''''''
88987	89298	{
88988	89299	// ACCUMULATE ARGUMENTS - BEGIN
88989	89300	{

		@@ -89019,7 +89330,7 @@
89019	89330	LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89020	89331	}
89021	89332	// ACCUMULATE ARGUMENTS - END
89022		- uint64_t return_to = 18446744073709545923LLU;
	89333	+ uint64_t return_to = 18446744073709545908LLU;
89023	89334	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0));
89024	89335	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89025	89336	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89028,43 +89339,43 @@
89028	89339	state.addr = 787472336332954560LLU; // procprint_
89029	89340	break;
89030	89341	}
89031		- case 18446744073709545923LLU: // 99999998lC'''''''''''''''
	89342	+ case 18446744073709545908LLU: // 99999998ky'''''''''''''''
89032	89343	{
89033		- state.addr = 18446744073709545924LLU; // 99999998lD'''''''''''''''
	89344	+ state.addr = 18446744073709545909LLU; // 99999998kz'''''''''''''''
89034	89345	break;
89035	89346	}
89036		- case 18446744073709545924LLU: // 99999998lD'''''''''''''''
	89347	+ case 18446744073709545909LLU: // 99999998kz'''''''''''''''
89037	89348	{
89038	89349	heap.availilable_size_for_dynamic_objects += 0LLU;
89039	89350	heap.availilable_size_for_dynamic_objects += 0LLU;
89040		- state.addr = 18446744073709545922LLU; // 99999998lB'''''''''''''''
	89351	+ state.addr = 18446744073709545907LLU; // 99999998kx'''''''''''''''
89041	89352	break;
89042	89353	}
89043		- case 18446744073709545925LLU: // 99999998lE'''''''''''''''
	89354	+ case 18446744073709545910LLU: // 99999998k0'''''''''''''''
89044	89355	{
89045	89356
89046		- state.addr = 18446744073709545921LLU; // 99999998lA'''''''''''''''
	89357	+ state.addr = 18446744073709545906LLU; // 99999998kw'''''''''''''''
89047	89358	break;
89048	89359	}
89049		- case 18446744073709545921LLU: // 99999998lA'''''''''''''''
	89360	+ case 18446744073709545906LLU: // 99999998kw'''''''''''''''
89050	89361	{
89051	89362	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047576934182;
89052	89363
89053		- state.addr = 18446744073709545920LLU; // 99999998l_'''''''''''''''
	89364	+ state.addr = 18446744073709545905LLU; // 99999998kv'''''''''''''''
89054	89365	break;
89055	89366	}
89056		- case 18446744073709545920LLU: // 99999998l_'''''''''''''''
	89367	+ case 18446744073709545905LLU: // 99999998kv'''''''''''''''
89057	89368	{
89058	89369	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89059		- state.addr = 18446744073709545919LLU; // 99999998k9'''''''''''''''
	89370	+ state.addr = 18446744073709545904LLU; // 99999998ku'''''''''''''''
89060	89371	break;
89061	89372	}
89062		- case 18446744073709545919LLU: // 99999998k9'''''''''''''''
	89373	+ case 18446744073709545904LLU: // 99999998ku'''''''''''''''
89063	89374	{
89064		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545918LLU : 18446744073709545917LLU;
	89375	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545903LLU : 18446744073709545902LLU;
89065	89376	break;
89066	89377	}
89067		- case 18446744073709545918LLU: // 99999998k8'''''''''''''''
	89378	+ case 18446744073709545903LLU: // 99999998kt'''''''''''''''
89068	89379	{
89069	89380	// ACCUMULATE ARGUMENTS - BEGIN
89070	89381	{

		@@ -89108,7 +89419,7 @@
89108	89419	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89109	89420	}
89110	89421	// ACCUMULATE ARGUMENTS - END
89111		- uint64_t return_to = 18446744073709545915LLU;
	89422	+ uint64_t return_to = 18446744073709545900LLU;
89112	89423	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0));
89113	89424	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89114	89425	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89117,43 +89428,43 @@
89117	89428	state.addr = 787463406843976550LLU; // prmatchbrk
89118	89429	break;
89119	89430	}
89120		- case 18446744073709545915LLU: // 99999998k5'''''''''''''''
	89431	+ case 18446744073709545900LLU: // 99999998kq'''''''''''''''
89121	89432	{
89122		- state.addr = 18446744073709545916LLU; // 99999998k6'''''''''''''''
	89433	+ state.addr = 18446744073709545901LLU; // 99999998kr'''''''''''''''
89123	89434	break;
89124	89435	}
89125		- case 18446744073709545916LLU: // 99999998k6'''''''''''''''
	89436	+ case 18446744073709545901LLU: // 99999998kr'''''''''''''''
89126	89437	{
89127	89438	heap.availilable_size_for_dynamic_objects += 0LLU;
89128	89439	heap.availilable_size_for_dynamic_objects += 0LLU;
89129		- state.addr = 18446744073709545914LLU; // 99999998k4'''''''''''''''
	89440	+ state.addr = 18446744073709545899LLU; // 99999998kp'''''''''''''''
89130	89441	break;
89131	89442	}
89132		- case 18446744073709545917LLU: // 99999998k7'''''''''''''''
	89443	+ case 18446744073709545902LLU: // 99999998ks'''''''''''''''
89133	89444	{
89134	89445
89135		- state.addr = 18446744073709545913LLU; // 99999998k3'''''''''''''''
	89446	+ state.addr = 18446744073709545898LLU; // 99999998ko'''''''''''''''
89136	89447	break;
89137	89448	}
89138		- case 18446744073709545913LLU: // 99999998k3'''''''''''''''
	89449	+ case 18446744073709545898LLU: // 99999998ko'''''''''''''''
89139	89450	{
89140	89451	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047690571776;
89141	89452
89142		- state.addr = 18446744073709545912LLU; // 99999998k2'''''''''''''''
	89453	+ state.addr = 18446744073709545897LLU; // 99999998kn'''''''''''''''
89143	89454	break;
89144	89455	}
89145		- case 18446744073709545912LLU: // 99999998k2'''''''''''''''
	89456	+ case 18446744073709545897LLU: // 99999998kn'''''''''''''''
89146	89457	{
89147	89458	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89148		- state.addr = 18446744073709545911LLU; // 99999998k1'''''''''''''''
	89459	+ state.addr = 18446744073709545896LLU; // 99999998km'''''''''''''''
89149	89460	break;
89150	89461	}
89151		- case 18446744073709545911LLU: // 99999998k1'''''''''''''''
	89462	+ case 18446744073709545896LLU: // 99999998km'''''''''''''''
89152	89463	{
89153		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545910LLU : 18446744073709545909LLU;
	89464	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545895LLU : 18446744073709545894LLU;
89154	89465	break;
89155	89466	}
89156		- case 18446744073709545910LLU: // 99999998k0'''''''''''''''
	89467	+ case 18446744073709545895LLU: // 99999998kl'''''''''''''''
89157	89468	{
89158	89469	// ACCUMULATE ARGUMENTS - BEGIN
89159	89470	{

		@@ -89197,7 +89508,7 @@
89197	89508	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89198	89509	}
89199	89510	// ACCUMULATE ARGUMENTS - END
89200		- uint64_t return_to = 18446744073709545907LLU;
	89511	+ uint64_t return_to = 18446744073709545892LLU;
89201	89512	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0));
89202	89513	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89203	89514	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89206,43 +89517,43 @@
89206	89517	state.addr = 787463406844004288LLU; // prmatchid_
89207	89518	break;
89208	89519	}
89209		- case 18446744073709545907LLU: // 99999998kx'''''''''''''''
	89520	+ case 18446744073709545892LLU: // 99999998ki'''''''''''''''
89210	89521	{
89211		- state.addr = 18446744073709545908LLU; // 99999998ky'''''''''''''''
	89522	+ state.addr = 18446744073709545893LLU; // 99999998kj'''''''''''''''
89212	89523	break;
89213	89524	}
89214		- case 18446744073709545908LLU: // 99999998ky'''''''''''''''
	89525	+ case 18446744073709545893LLU: // 99999998kj'''''''''''''''
89215	89526	{
89216	89527	heap.availilable_size_for_dynamic_objects += 0LLU;
89217	89528	heap.availilable_size_for_dynamic_objects += 0LLU;
89218		- state.addr = 18446744073709545906LLU; // 99999998kw'''''''''''''''
	89529	+ state.addr = 18446744073709545891LLU; // 99999998kh'''''''''''''''
89219	89530	break;
89220	89531	}
89221		- case 18446744073709545909LLU: // 99999998kz'''''''''''''''
	89532	+ case 18446744073709545894LLU: // 99999998kk'''''''''''''''
89222	89533	{
89223	89534
89224		- state.addr = 18446744073709545905LLU; // 99999998kv'''''''''''''''
	89535	+ state.addr = 18446744073709545890LLU; // 99999998kg'''''''''''''''
89225	89536	break;
89226	89537	}
89227		- case 18446744073709545905LLU: // 99999998kv'''''''''''''''
	89538	+ case 18446744073709545890LLU: // 99999998kg'''''''''''''''
89228	89539	{
89229	89540	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 787472324541022208;
89230	89541
89231		- state.addr = 18446744073709545904LLU; // 99999998ku'''''''''''''''
	89542	+ state.addr = 18446744073709545889LLU; // 99999998kf'''''''''''''''
89232	89543	break;
89233	89544	}
89234		- case 18446744073709545904LLU: // 99999998ku'''''''''''''''
	89545	+ case 18446744073709545889LLU: // 99999998kf'''''''''''''''
89235	89546	{
89236	89547	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89237		- state.addr = 18446744073709545903LLU; // 99999998kt'''''''''''''''
	89548	+ state.addr = 18446744073709545888LLU; // 99999998ke'''''''''''''''
89238	89549	break;
89239	89550	}
89240		- case 18446744073709545903LLU: // 99999998kt'''''''''''''''
	89551	+ case 18446744073709545888LLU: // 99999998ke'''''''''''''''
89241	89552	{
89242		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545902LLU : 18446744073709545901LLU;
	89553	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545887LLU : 18446744073709545886LLU;
89243	89554	break;
89244	89555	}
89245		- case 18446744073709545902LLU: // 99999998ks'''''''''''''''
	89556	+ case 18446744073709545887LLU: // 99999998kd'''''''''''''''
89246	89557	{
89247	89558	// ACCUMULATE ARGUMENTS - BEGIN
89248	89559	{

		@@ -89294,7 +89605,7 @@
89294	89605	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89295	89606	}
89296	89607	// ACCUMULATE ARGUMENTS - END
89297		- uint64_t return_to = 18446744073709545899LLU;
	89608	+ uint64_t return_to = 18446744073709545884LLU;
89298	89609	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
89299	89610	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89300	89611	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89303,43 +89614,43 @@
89303	89614	state.addr = 787420455223561134LLU; // prcprocess
89304	89615	break;
89305	89616	}
89306		- case 18446744073709545899LLU: // 99999998kp'''''''''''''''
	89617	+ case 18446744073709545884LLU: // 99999998ka'''''''''''''''
89307	89618	{
89308		- state.addr = 18446744073709545900LLU; // 99999998kq'''''''''''''''
	89619	+ state.addr = 18446744073709545885LLU; // 99999998kb'''''''''''''''
89309	89620	break;
89310	89621	}
89311		- case 18446744073709545900LLU: // 99999998kq'''''''''''''''
	89622	+ case 18446744073709545885LLU: // 99999998kb'''''''''''''''
89312	89623	{
89313	89624	heap.availilable_size_for_dynamic_objects += 0LLU;
89314	89625	heap.availilable_size_for_dynamic_objects += 0LLU;
89315		- state.addr = 18446744073709545898LLU; // 99999998ko'''''''''''''''
	89626	+ state.addr = 18446744073709545883LLU; // 99999998k$'''''''''''''''
89316	89627	break;
89317	89628	}
89318		- case 18446744073709545901LLU: // 99999998kr'''''''''''''''
	89629	+ case 18446744073709545886LLU: // 99999998kc'''''''''''''''
89319	89630	{
89320	89631
89321		- state.addr = 18446744073709545897LLU; // 99999998kn'''''''''''''''
	89632	+ state.addr = 18446744073709545882LLU; // 99999998kZ'''''''''''''''
89322	89633	break;
89323	89634	}
89324		- case 18446744073709545897LLU: // 99999998kn'''''''''''''''
	89635	+ case 18446744073709545882LLU: // 99999998kZ'''''''''''''''
89325	89636	{
89326	89637	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 606497241528270848;
89327	89638
89328		- state.addr = 18446744073709545896LLU; // 99999998km'''''''''''''''
	89639	+ state.addr = 18446744073709545881LLU; // 99999998kY'''''''''''''''
89329	89640	break;
89330	89641	}
89331		- case 18446744073709545896LLU: // 99999998km'''''''''''''''
	89642	+ case 18446744073709545881LLU: // 99999998kY'''''''''''''''
89332	89643	{
89333	89644	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89334		- state.addr = 18446744073709545895LLU; // 99999998kl'''''''''''''''
	89645	+ state.addr = 18446744073709545880LLU; // 99999998kX'''''''''''''''
89335	89646	break;
89336	89647	}
89337		- case 18446744073709545895LLU: // 99999998kl'''''''''''''''
	89648	+ case 18446744073709545880LLU: // 99999998kX'''''''''''''''
89338	89649	{
89339		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545894LLU : 18446744073709545893LLU;
	89650	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545879LLU : 18446744073709545878LLU;
89340	89651	break;
89341	89652	}
89342		- case 18446744073709545894LLU: // 99999998kk'''''''''''''''
	89653	+ case 18446744073709545879LLU: // 99999998kW'''''''''''''''
89343	89654	{
89344	89655	// ACCUMULATE ARGUMENTS - BEGIN
89345	89656	{

		@@ -89391,7 +89702,7 @@
89391	89702	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89392	89703	}
89393	89704	// ACCUMULATE ARGUMENTS - END
89394		- uint64_t return_to = 18446744073709545891LLU;
	89705	+ uint64_t return_to = 18446744073709545876LLU;
89395	89706	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
89396	89707	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89397	89708	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89400,43 +89711,43 @@
89400	89711	state.addr = 787419764858406819LLU; // prcforeach
89401	89712	break;
89402	89713	}
89403		- case 18446744073709545891LLU: // 99999998kh'''''''''''''''
	89714	+ case 18446744073709545876LLU: // 99999998kT'''''''''''''''
89404	89715	{
89405		- state.addr = 18446744073709545892LLU; // 99999998ki'''''''''''''''
	89716	+ state.addr = 18446744073709545877LLU; // 99999998kU'''''''''''''''
89406	89717	break;
89407	89718	}
89408		- case 18446744073709545892LLU: // 99999998ki'''''''''''''''
	89719	+ case 18446744073709545877LLU: // 99999998kU'''''''''''''''
89409	89720	{
89410	89721	heap.availilable_size_for_dynamic_objects += 0LLU;
89411	89722	heap.availilable_size_for_dynamic_objects += 0LLU;
89412		- state.addr = 18446744073709545890LLU; // 99999998kg'''''''''''''''
	89723	+ state.addr = 18446744073709545875LLU; // 99999998kS'''''''''''''''
89413	89724	break;
89414	89725	}
89415		- case 18446744073709545893LLU: // 99999998kj'''''''''''''''
	89726	+ case 18446744073709545878LLU: // 99999998kV'''''''''''''''
89416	89727	{
89417	89728
89418		- state.addr = 18446744073709545889LLU; // 99999998kf'''''''''''''''
	89729	+ state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
89419	89730	break;
89420	89731	}
89421		- case 18446744073709545889LLU: // 99999998kf'''''''''''''''
	89732	+ case 18446744073709545874LLU: // 99999998kR'''''''''''''''
89422	89733	{
89423	89734	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 552467879034563136;
89424	89735
89425		- state.addr = 18446744073709545888LLU; // 99999998ke'''''''''''''''
	89736	+ state.addr = 18446744073709545873LLU; // 99999998kQ'''''''''''''''
89426	89737	break;
89427	89738	}
89428		- case 18446744073709545888LLU: // 99999998ke'''''''''''''''
	89739	+ case 18446744073709545873LLU: // 99999998kQ'''''''''''''''
89429	89740	{
89430	89741	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89431		- state.addr = 18446744073709545887LLU; // 99999998kd'''''''''''''''
	89742	+ state.addr = 18446744073709545872LLU; // 99999998kP'''''''''''''''
89432	89743	break;
89433	89744	}
89434		- case 18446744073709545887LLU: // 99999998kd'''''''''''''''
	89745	+ case 18446744073709545872LLU: // 99999998kP'''''''''''''''
89435	89746	{
89436		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545886LLU : 18446744073709545885LLU;
	89747	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545871LLU : 18446744073709545870LLU;
89437	89748	break;
89438	89749	}
89439		- case 18446744073709545886LLU: // 99999998kc'''''''''''''''
	89750	+ case 18446744073709545871LLU: // 99999998kO'''''''''''''''
89440	89751	{
89441	89752	{
89442	89753	uint64_t arg = 0;

		@@ -89489,7 +89800,7 @@
89489	89800	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89490	89801	}
89491	89802	// ACCUMULATE ARGUMENTS - END
89492		- uint64_t return_to = 18446744073709545883LLU;
	89803	+ uint64_t return_to = 18446744073709545868LLU;
89493	89804	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
89494	89805	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89495	89806	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89498,12 +89809,12 @@
89498	89809	state.addr = 783251446517640361LLU; // pcountdown
89499	89810	break;
89500	89811	}
89501		- case 18446744073709545883LLU: // 99999998k$'''''''''''''''
	89812	+ case 18446744073709545868LLU: // 99999998kL'''''''''''''''
89502	89813	{
89503		- state.addr = 18446744073709545884LLU; // 99999998ka'''''''''''''''
	89814	+ state.addr = 18446744073709545869LLU; // 99999998kM'''''''''''''''
89504	89815	break;
89505	89816	}
89506		- case 18446744073709545884LLU: // 99999998ka'''''''''''''''
	89817	+ case 18446744073709545869LLU: // 99999998kM'''''''''''''''
89507	89818	{
89508	89819	// variable u64 callee_id_ goes out of scope
89509	89820	// emitted destructur for type u64

		@@ -89510,34 +89821,34 @@
89510	89821	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference callee_id_ at 20
89511	89822	heap.availilable_size_for_dynamic_objects += 0LLU;
89512	89823	heap.availilable_size_for_dynamic_objects += 0LLU;
89513		- state.addr = 18446744073709545882LLU; // 99999998kZ'''''''''''''''
	89824	+ state.addr = 18446744073709545867LLU; // 99999998kK'''''''''''''''
89514	89825	break;
89515	89826	}
89516		- case 18446744073709545885LLU: // 99999998kb'''''''''''''''
	89827	+ case 18446744073709545870LLU: // 99999998kN'''''''''''''''
89517	89828	{
89518	89829
89519		- state.addr = 18446744073709545881LLU; // 99999998kY'''''''''''''''
	89830	+ state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
89520	89831	break;
89521	89832	}
89522		- case 18446744073709545881LLU: // 99999998kY'''''''''''''''
	89833	+ case 18446744073709545866LLU: // 99999998kJ'''''''''''''''
89523	89834	{
89524	89835	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 768306405604851712;
89525	89836
89526		- state.addr = 18446744073709545880LLU; // 99999998kX'''''''''''''''
	89837	+ state.addr = 18446744073709545865LLU; // 99999998kI'''''''''''''''
89527	89838	break;
89528	89839	}
89529		- case 18446744073709545880LLU: // 99999998kX'''''''''''''''
	89840	+ case 18446744073709545865LLU: // 99999998kI'''''''''''''''
89530	89841	{
89531	89842	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89532		- state.addr = 18446744073709545879LLU; // 99999998kW'''''''''''''''
	89843	+ state.addr = 18446744073709545864LLU; // 99999998kH'''''''''''''''
89533	89844	break;
89534	89845	}
89535		- case 18446744073709545879LLU: // 99999998kW'''''''''''''''
	89846	+ case 18446744073709545864LLU: // 99999998kH'''''''''''''''
89536	89847	{
89537		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545878LLU : 18446744073709545877LLU;
	89848	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545863LLU : 18446744073709545862LLU;
89538	89849	break;
89539	89850	}
89540		- case 18446744073709545878LLU: // 99999998kV'''''''''''''''
	89851	+ case 18446744073709545863LLU: // 99999998kG'''''''''''''''
89541	89852	{
89542	89853	// ACCUMULATE ARGUMENTS - BEGIN
89543	89854	{

		@@ -89585,7 +89896,7 @@
89585	89896	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89586	89897	}
89587	89898	// ACCUMULATE ARGUMENTS - END
89588		- uint64_t return_to = 18446744073709545875LLU;
	89899	+ uint64_t return_to = 18446744073709545860LLU;
89589	89900	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
89590	89901	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89591	89902	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89594,43 +89905,43 @@
89594	89905	state.addr = 787420382111382575LLU; // prconinput
89595	89906	break;
89596	89907	}
89597		- case 18446744073709545875LLU: // 99999998kS'''''''''''''''
	89908	+ case 18446744073709545860LLU: // 99999998kD'''''''''''''''
89598	89909	{
89599		- state.addr = 18446744073709545876LLU; // 99999998kT'''''''''''''''
	89910	+ state.addr = 18446744073709545861LLU; // 99999998kE'''''''''''''''
89600	89911	break;
89601	89912	}
89602		- case 18446744073709545876LLU: // 99999998kT'''''''''''''''
	89913	+ case 18446744073709545861LLU: // 99999998kE'''''''''''''''
89603	89914	{
89604	89915	heap.availilable_size_for_dynamic_objects += 0LLU;
89605	89916	heap.availilable_size_for_dynamic_objects += 0LLU;
89606		- state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
	89917	+ state.addr = 18446744073709545859LLU; // 99999998kC'''''''''''''''
89607	89918	break;
89608	89919	}
89609		- case 18446744073709545877LLU: // 99999998kU'''''''''''''''
	89920	+ case 18446744073709545862LLU: // 99999998kF'''''''''''''''
89610	89921	{
89611	89922
89612		- state.addr = 18446744073709545873LLU; // 99999998kQ'''''''''''''''
	89923	+ state.addr = 18446744073709545858LLU; // 99999998kB'''''''''''''''
89613	89924	break;
89614	89925	}
89615		- case 18446744073709545873LLU: // 99999998kQ'''''''''''''''
	89926	+ case 18446744073709545858LLU: // 99999998kB'''''''''''''''
89616	89927	{
89617	89928	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 910732593752702976;
89618	89929
89619		- state.addr = 18446744073709545872LLU; // 99999998kP'''''''''''''''
	89930	+ state.addr = 18446744073709545857LLU; // 99999998kA'''''''''''''''
89620	89931	break;
89621	89932	}
89622		- case 18446744073709545872LLU: // 99999998kP'''''''''''''''
	89933	+ case 18446744073709545857LLU: // 99999998kA'''''''''''''''
89623	89934	{
89624	89935	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89625		- state.addr = 18446744073709545871LLU; // 99999998kO'''''''''''''''
	89936	+ state.addr = 18446744073709545856LLU; // 99999998k_'''''''''''''''
89626	89937	break;
89627	89938	}
89628		- case 18446744073709545871LLU: // 99999998kO'''''''''''''''
	89939	+ case 18446744073709545856LLU: // 99999998k_'''''''''''''''
89629	89940	{
89630		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545870LLU : 18446744073709545869LLU;
	89941	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545855LLU : 18446744073709545854LLU;
89631	89942	break;
89632	89943	}
89633		- case 18446744073709545870LLU: // 99999998kN'''''''''''''''
	89944	+ case 18446744073709545855LLU: // 99999998j9'''''''''''''''
89634	89945	{
89635	89946	// ACCUMULATE ARGUMENTS - BEGIN
89636	89947	{

		@@ -89682,7 +89993,7 @@
89682	89993	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89683	89994	}
89684	89995	// ACCUMULATE ARGUMENTS - END
89685		- uint64_t return_to = 18446744073709545867LLU;
	89996	+ uint64_t return_to = 18446744073709545852LLU;
89686	89997	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
89687	89998	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89688	89999	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89691,43 +90002,43 @@
89691	90002	state.addr = 787472343681366016LLU; // procwhile_
89692	90003	break;
89693	90004	}
89694		- case 18446744073709545867LLU: // 99999998kK'''''''''''''''
	90005	+ case 18446744073709545852LLU: // 99999998j6'''''''''''''''
89695	90006	{
89696		- state.addr = 18446744073709545868LLU; // 99999998kL'''''''''''''''
	90007	+ state.addr = 18446744073709545853LLU; // 99999998j7'''''''''''''''
89697	90008	break;
89698	90009	}
89699		- case 18446744073709545868LLU: // 99999998kL'''''''''''''''
	90010	+ case 18446744073709545853LLU: // 99999998j7'''''''''''''''
89700	90011	{
89701	90012	heap.availilable_size_for_dynamic_objects += 0LLU;
89702	90013	heap.availilable_size_for_dynamic_objects += 0LLU;
89703		- state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
	90014	+ state.addr = 18446744073709545851LLU; // 99999998j5'''''''''''''''
89704	90015	break;
89705	90016	}
89706		- case 18446744073709545869LLU: // 99999998kM'''''''''''''''
	90017	+ case 18446744073709545854LLU: // 99999998j8'''''''''''''''
89707	90018	{
89708	90019
89709		- state.addr = 18446744073709545865LLU; // 99999998kI'''''''''''''''
	90020	+ state.addr = 18446744073709545850LLU; // 99999998j4'''''''''''''''
89710	90021	break;
89711	90022	}
89712		- case 18446744073709545865LLU: // 99999998kI'''''''''''''''
	90023	+ case 18446744073709545850LLU: // 99999998j4'''''''''''''''
89713	90024	{
89714	90025	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 910715104645873664;
89715	90026
89716		- state.addr = 18446744073709545864LLU; // 99999998kH'''''''''''''''
	90027	+ state.addr = 18446744073709545849LLU; // 99999998j3'''''''''''''''
89717	90028	break;
89718	90029	}
89719		- case 18446744073709545864LLU: // 99999998kH'''''''''''''''
	90030	+ case 18446744073709545849LLU: // 99999998j3'''''''''''''''
89720	90031	{
89721	90032	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89722		- state.addr = 18446744073709545863LLU; // 99999998kG'''''''''''''''
	90033	+ state.addr = 18446744073709545848LLU; // 99999998j2'''''''''''''''
89723	90034	break;
89724	90035	}
89725		- case 18446744073709545863LLU: // 99999998kG'''''''''''''''
	90036	+ case 18446744073709545848LLU: // 99999998j2'''''''''''''''
89726	90037	{
89727		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545862LLU : 18446744073709545861LLU;
	90038	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545847LLU : 18446744073709545846LLU;
89728	90039	break;
89729	90040	}
89730		- case 18446744073709545862LLU: // 99999998kF'''''''''''''''
	90041	+ case 18446744073709545847LLU: // 99999998j1'''''''''''''''
89731	90042	{
89732	90043	// ACCUMULATE ARGUMENTS - BEGIN
89733	90044	{

		@@ -89795,7 +90106,7 @@
89795	90106	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89796	90107	}
89797	90108	// ACCUMULATE ARGUMENTS - END
89798		- uint64_t return_to = 18446744073709545859LLU;
	90109	+ uint64_t return_to = 18446744073709545844LLU;
89799	90110	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0));
89800	90111	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89801	90112	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89804,43 +90115,43 @@
89804	90115	state.addr = 787472343680323584LLU; // procwhen__
89805	90116	break;
89806	90117	}
89807		- case 18446744073709545859LLU: // 99999998kC'''''''''''''''
	90118	+ case 18446744073709545844LLU: // 99999998jy'''''''''''''''
89808	90119	{
89809		- state.addr = 18446744073709545860LLU; // 99999998kD'''''''''''''''
	90120	+ state.addr = 18446744073709545845LLU; // 99999998jz'''''''''''''''
89810	90121	break;
89811	90122	}
89812		- case 18446744073709545860LLU: // 99999998kD'''''''''''''''
	90123	+ case 18446744073709545845LLU: // 99999998jz'''''''''''''''
89813	90124	{
89814	90125	heap.availilable_size_for_dynamic_objects += 0LLU;
89815	90126	heap.availilable_size_for_dynamic_objects += 0LLU;
89816		- state.addr = 18446744073709545858LLU; // 99999998kB'''''''''''''''
	90127	+ state.addr = 18446744073709545843LLU; // 99999998jx'''''''''''''''
89817	90128	break;
89818	90129	}
89819		- case 18446744073709545861LLU: // 99999998kE'''''''''''''''
	90130	+ case 18446744073709545846LLU: // 99999998j0'''''''''''''''
89820	90131	{
89821	90132
89822		- state.addr = 18446744073709545857LLU; // 99999998kA'''''''''''''''
	90133	+ state.addr = 18446744073709545842LLU; // 99999998jw'''''''''''''''
89823	90134	break;
89824	90135	}
89825		- case 18446744073709545857LLU: // 99999998kA'''''''''''''''
	90136	+ case 18446744073709545842LLU: // 99999998jw'''''''''''''''
89826	90137	{
89827	90138	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 657807020572803072;
89828	90139
89829		- state.addr = 18446744073709545856LLU; // 99999998k_'''''''''''''''
	90140	+ state.addr = 18446744073709545841LLU; // 99999998jv'''''''''''''''
89830	90141	break;
89831	90142	}
89832		- case 18446744073709545856LLU: // 99999998k_'''''''''''''''
	90143	+ case 18446744073709545841LLU: // 99999998jv'''''''''''''''
89833	90144	{
89834	90145	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89835		- state.addr = 18446744073709545855LLU; // 99999998j9'''''''''''''''
	90146	+ state.addr = 18446744073709545840LLU; // 99999998ju'''''''''''''''
89836	90147	break;
89837	90148	}
89838		- case 18446744073709545855LLU: // 99999998j9'''''''''''''''
	90149	+ case 18446744073709545840LLU: // 99999998ju'''''''''''''''
89839	90150	{
89840		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545854LLU : 18446744073709545853LLU;
	90151	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545839LLU : 18446744073709545838LLU;
89841	90152	break;
89842	90153	}
89843		- case 18446744073709545854LLU: // 99999998j8'''''''''''''''
	90154	+ case 18446744073709545839LLU: // 99999998jt'''''''''''''''
89844	90155	{
89845	90156	// ACCUMULATE ARGUMENTS - BEGIN
89846	90157	{

		@@ -89908,7 +90219,7 @@
89908	90219	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
89909	90220	}
89910	90221	// ACCUMULATE ARGUMENTS - END
89911		- uint64_t return_to = 18446744073709545851LLU;
	90222	+ uint64_t return_to = 18446744073709545836LLU;
89912	90223	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0));
89913	90224	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
89914	90225	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -89917,43 +90228,43 @@
89917	90228	state.addr = 787472328605827072LLU; // procif____
89918	90229	break;
89919	90230	}
89920		- case 18446744073709545851LLU: // 99999998j5'''''''''''''''
	90231	+ case 18446744073709545836LLU: // 99999998jq'''''''''''''''
89921	90232	{
89922		- state.addr = 18446744073709545852LLU; // 99999998j6'''''''''''''''
	90233	+ state.addr = 18446744073709545837LLU; // 99999998jr'''''''''''''''
89923	90234	break;
89924	90235	}
89925		- case 18446744073709545852LLU: // 99999998j6'''''''''''''''
	90236	+ case 18446744073709545837LLU: // 99999998jr'''''''''''''''
89926	90237	{
89927	90238	heap.availilable_size_for_dynamic_objects += 0LLU;
89928	90239	heap.availilable_size_for_dynamic_objects += 0LLU;
89929		- state.addr = 18446744073709545850LLU; // 99999998j4'''''''''''''''
	90240	+ state.addr = 18446744073709545835LLU; // 99999998jp'''''''''''''''
89930	90241	break;
89931	90242	}
89932		- case 18446744073709545853LLU: // 99999998j7'''''''''''''''
	90243	+ case 18446744073709545838LLU: // 99999998js'''''''''''''''
89933	90244	{
89934	90245
89935		- state.addr = 18446744073709545849LLU; // 99999998j3'''''''''''''''
	90246	+ state.addr = 18446744073709545834LLU; // 99999998jo'''''''''''''''
89936	90247	break;
89937	90248	}
89938		- case 18446744073709545849LLU: // 99999998j3'''''''''''''''
	90249	+ case 18446744073709545834LLU: // 99999998jo'''''''''''''''
89939	90250	{
89940	90251	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 512981598149279744;
89941	90252
89942		- state.addr = 18446744073709545848LLU; // 99999998j2'''''''''''''''
	90253	+ state.addr = 18446744073709545833LLU; // 99999998jn'''''''''''''''
89943	90254	break;
89944	90255	}
89945		- case 18446744073709545848LLU: // 99999998j2'''''''''''''''
	90256	+ case 18446744073709545833LLU: // 99999998jn'''''''''''''''
89946	90257	{
89947	90258	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
89948		- state.addr = 18446744073709545847LLU; // 99999998j1'''''''''''''''
	90259	+ state.addr = 18446744073709545832LLU; // 99999998jm'''''''''''''''
89949	90260	break;
89950	90261	}
89951		- case 18446744073709545847LLU: // 99999998j1'''''''''''''''
	90262	+ case 18446744073709545832LLU: // 99999998jm'''''''''''''''
89952	90263	{
89953		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545846LLU : 18446744073709545845LLU;
	90264	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545831LLU : 18446744073709545830LLU;
89954	90265	break;
89955	90266	}
89956		- case 18446744073709545846LLU: // 99999998j0'''''''''''''''
	90267	+ case 18446744073709545831LLU: // 99999998jl'''''''''''''''
89957	90268	{
89958	90269	// ACCUMULATE ARGUMENTS - BEGIN
89959	90270	{

		@@ -90005,7 +90316,7 @@
90005	90316	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90006	90317	}
90007	90318	// ACCUMULATE ARGUMENTS - END
90008		- uint64_t return_to = 18446744073709545843LLU;
	90319	+ uint64_t return_to = 18446744073709545828LLU;
90009	90320	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
90010	90321	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90011	90322	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90014,43 +90325,43 @@
90014	90325	state.addr = 787472319973559214LLU; // procaccess
90015	90326	break;
90016	90327	}
90017		- case 18446744073709545843LLU: // 99999998jx'''''''''''''''
	90328	+ case 18446744073709545828LLU: // 99999998ji'''''''''''''''
90018	90329	{
90019		- state.addr = 18446744073709545844LLU; // 99999998jy'''''''''''''''
	90330	+ state.addr = 18446744073709545829LLU; // 99999998jj'''''''''''''''
90020	90331	break;
90021	90332	}
90022		- case 18446744073709545844LLU: // 99999998jy'''''''''''''''
	90333	+ case 18446744073709545829LLU: // 99999998jj'''''''''''''''
90023	90334	{
90024	90335	heap.availilable_size_for_dynamic_objects += 0LLU;
90025	90336	heap.availilable_size_for_dynamic_objects += 0LLU;
90026		- state.addr = 18446744073709545842LLU; // 99999998jw'''''''''''''''
	90337	+ state.addr = 18446744073709545827LLU; // 99999998jh'''''''''''''''
90027	90338	break;
90028	90339	}
90029		- case 18446744073709545845LLU: // 99999998jz'''''''''''''''
	90340	+ case 18446744073709545830LLU: // 99999998jk'''''''''''''''
90030	90341	{
90031	90342
90032		- state.addr = 18446744073709545841LLU; // 99999998jv'''''''''''''''
	90343	+ state.addr = 18446744073709545826LLU; // 99999998jg'''''''''''''''
90033	90344	break;
90034	90345	}
90035		- case 18446744073709545841LLU: // 99999998jv'''''''''''''''
	90346	+ case 18446744073709545826LLU: // 99999998jg'''''''''''''''
90036	90347	{
90037	90348	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047090961088;
90038	90349
90039		- state.addr = 18446744073709545840LLU; // 99999998ju'''''''''''''''
	90350	+ state.addr = 18446744073709545825LLU; // 99999998jf'''''''''''''''
90040	90351	break;
90041	90352	}
90042		- case 18446744073709545840LLU: // 99999998ju'''''''''''''''
	90353	+ case 18446744073709545825LLU: // 99999998jf'''''''''''''''
90043	90354	{
90044	90355	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90045		- state.addr = 18446744073709545839LLU; // 99999998jt'''''''''''''''
	90356	+ state.addr = 18446744073709545824LLU; // 99999998je'''''''''''''''
90046	90357	break;
90047	90358	}
90048		- case 18446744073709545839LLU: // 99999998jt'''''''''''''''
	90359	+ case 18446744073709545824LLU: // 99999998je'''''''''''''''
90049	90360	{
90050		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545838LLU : 18446744073709545837LLU;
	90361	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545823LLU : 18446744073709545822LLU;
90051	90362	break;
90052	90363	}
90053		- case 18446744073709545838LLU: // 99999998js'''''''''''''''
	90364	+ case 18446744073709545823LLU: // 99999998jd'''''''''''''''
90054	90365	{
90055	90366	// ACCUMULATE ARGUMENTS - BEGIN
90056	90367	{

		@@ -90102,7 +90413,7 @@
90102	90413	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90103	90414	}
90104	90415	// ACCUMULATE ARGUMENTS - END
90105		- uint64_t return_to = 18446744073709545835LLU;
	90416	+ uint64_t return_to = 18446744073709545820LLU;
90106	90417	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
90107	90418	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90108	90419	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90111,43 +90422,43 @@
90111	90422	state.addr = 787463406844050091LLU; // prmatchtop
90112	90423	break;
90113	90424	}
90114		- case 18446744073709545835LLU: // 99999998jp'''''''''''''''
	90425	+ case 18446744073709545820LLU: // 99999998ja'''''''''''''''
90115	90426	{
90116		- state.addr = 18446744073709545836LLU; // 99999998jq'''''''''''''''
	90427	+ state.addr = 18446744073709545821LLU; // 99999998jb'''''''''''''''
90117	90428	break;
90118	90429	}
90119		- case 18446744073709545836LLU: // 99999998jq'''''''''''''''
	90430	+ case 18446744073709545821LLU: // 99999998jb'''''''''''''''
90120	90431	{
90121	90432	heap.availilable_size_for_dynamic_objects += 0LLU;
90122	90433	heap.availilable_size_for_dynamic_objects += 0LLU;
90123		- state.addr = 18446744073709545834LLU; // 99999998jo'''''''''''''''
	90434	+ state.addr = 18446744073709545819LLU; // 99999998j$'''''''''''''''
90124	90435	break;
90125	90436	}
90126		- case 18446744073709545837LLU: // 99999998jr'''''''''''''''
	90437	+ case 18446744073709545822LLU: // 99999998jc'''''''''''''''
90127	90438	{
90128	90439
90129		- state.addr = 18446744073709545833LLU; // 99999998jn'''''''''''''''
	90440	+ state.addr = 18446744073709545818LLU; // 99999998jZ'''''''''''''''
90130	90441	break;
90131	90442	}
90132		- case 18446744073709545833LLU: // 99999998jn'''''''''''''''
	90443	+ case 18446744073709545818LLU: // 99999998jZ'''''''''''''''
90133	90444	{
90134	90445	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 657999485095758119;
90135	90446
90136		- state.addr = 18446744073709545832LLU; // 99999998jm'''''''''''''''
	90447	+ state.addr = 18446744073709545817LLU; // 99999998jY'''''''''''''''
90137	90448	break;
90138	90449	}
90139		- case 18446744073709545832LLU: // 99999998jm'''''''''''''''
	90450	+ case 18446744073709545817LLU: // 99999998jY'''''''''''''''
90140	90451	{
90141	90452	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90142		- state.addr = 18446744073709545831LLU; // 99999998jl'''''''''''''''
	90453	+ state.addr = 18446744073709545816LLU; // 99999998jX'''''''''''''''
90143	90454	break;
90144	90455	}
90145		- case 18446744073709545831LLU: // 99999998jl'''''''''''''''
	90456	+ case 18446744073709545816LLU: // 99999998jX'''''''''''''''
90146	90457	{
90147		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545830LLU : 18446744073709545829LLU;
	90458	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545815LLU : 18446744073709545814LLU;
90148	90459	break;
90149	90460	}
90150		- case 18446744073709545830LLU: // 99999998jk'''''''''''''''
	90461	+ case 18446744073709545815LLU: // 99999998jW'''''''''''''''
90151	90462	{
90152	90463	// ACCUMULATE ARGUMENTS - BEGIN
90153	90464	{

		@@ -90215,7 +90526,7 @@
90215	90526	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90216	90527	}
90217	90528	// ACCUMULATE ARGUMENTS - END
90218		- uint64_t return_to = 18446744073709545827LLU;
	90529	+ uint64_t return_to = 18446744073709545812LLU;
90219	90530	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0));
90220	90531	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90221	90532	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90224,43 +90535,43 @@
90224	90535	state.addr = 787420730272713635LLU; // prctrypush
90225	90536	break;
90226	90537	}
90227		- case 18446744073709545827LLU: // 99999998jh'''''''''''''''
	90538	+ case 18446744073709545812LLU: // 99999998jT'''''''''''''''
90228	90539	{
90229		- state.addr = 18446744073709545828LLU; // 99999998ji'''''''''''''''
	90540	+ state.addr = 18446744073709545813LLU; // 99999998jU'''''''''''''''
90230	90541	break;
90231	90542	}
90232		- case 18446744073709545828LLU: // 99999998ji'''''''''''''''
	90543	+ case 18446744073709545813LLU: // 99999998jU'''''''''''''''
90233	90544	{
90234	90545	heap.availilable_size_for_dynamic_objects += 0LLU;
90235	90546	heap.availilable_size_for_dynamic_objects += 0LLU;
90236		- state.addr = 18446744073709545826LLU; // 99999998jg'''''''''''''''
	90547	+ state.addr = 18446744073709545811LLU; // 99999998jS'''''''''''''''
90237	90548	break;
90238	90549	}
90239		- case 18446744073709545829LLU: // 99999998jj'''''''''''''''
	90550	+ case 18446744073709545814LLU: // 99999998jV'''''''''''''''
90240	90551	{
90241	90552
90242		- state.addr = 18446744073709545825LLU; // 99999998jf'''''''''''''''
	90553	+ state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
90243	90554	break;
90244	90555	}
90245		- case 18446744073709545825LLU: // 99999998jf'''''''''''''''
	90556	+ case 18446744073709545810LLU: // 99999998jR'''''''''''''''
90246	90557	{
90247	90558	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 819872884582252544;
90248	90559
90249		- state.addr = 18446744073709545824LLU; // 99999998je'''''''''''''''
	90560	+ state.addr = 18446744073709545809LLU; // 99999998jQ'''''''''''''''
90250	90561	break;
90251	90562	}
90252		- case 18446744073709545824LLU: // 99999998je'''''''''''''''
	90563	+ case 18446744073709545809LLU: // 99999998jQ'''''''''''''''
90253	90564	{
90254	90565	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90255		- state.addr = 18446744073709545823LLU; // 99999998jd'''''''''''''''
	90566	+ state.addr = 18446744073709545808LLU; // 99999998jP'''''''''''''''
90256	90567	break;
90257	90568	}
90258		- case 18446744073709545823LLU: // 99999998jd'''''''''''''''
	90569	+ case 18446744073709545808LLU: // 99999998jP'''''''''''''''
90259	90570	{
90260		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545822LLU : 18446744073709545821LLU;
	90571	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545807LLU : 18446744073709545806LLU;
90261	90572	break;
90262	90573	}
90263		- case 18446744073709545822LLU: // 99999998jc'''''''''''''''
	90574	+ case 18446744073709545807LLU: // 99999998jO'''''''''''''''
90264	90575	{
90265	90576	// ACCUMULATE ARGUMENTS - BEGIN
90266	90577	{

		@@ -90300,7 +90611,7 @@
90300	90611	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90301	90612	}
90302	90613	// ACCUMULATE ARGUMENTS - END
90303		- uint64_t return_to = 18446744073709545819LLU;
	90614	+ uint64_t return_to = 18446744073709545804LLU;
90304	90615	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
90305	90616	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90306	90617	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90309,43 +90620,43 @@
90309	90620	state.addr = 787472338265571328LLU; // procrev___
90310	90621	break;
90311	90622	}
90312		- case 18446744073709545819LLU: // 99999998j$'''''''''''''''
	90623	+ case 18446744073709545804LLU: // 99999998jL'''''''''''''''
90313	90624	{
90314		- state.addr = 18446744073709545820LLU; // 99999998ja'''''''''''''''
	90625	+ state.addr = 18446744073709545805LLU; // 99999998jM'''''''''''''''
90315	90626	break;
90316	90627	}
90317		- case 18446744073709545820LLU: // 99999998ja'''''''''''''''
	90628	+ case 18446744073709545805LLU: // 99999998jM'''''''''''''''
90318	90629	{
90319	90630	heap.availilable_size_for_dynamic_objects += 0LLU;
90320	90631	heap.availilable_size_for_dynamic_objects += 0LLU;
90321		- state.addr = 18446744073709545818LLU; // 99999998jZ'''''''''''''''
	90632	+ state.addr = 18446744073709545803LLU; // 99999998jK'''''''''''''''
90322	90633	break;
90323	90634	}
90324		- case 18446744073709545821LLU: // 99999998jb'''''''''''''''
	90635	+ case 18446744073709545806LLU: // 99999998jN'''''''''''''''
90325	90636	{
90326	90637
90327		- state.addr = 18446744073709545817LLU; // 99999998jY'''''''''''''''
	90638	+ state.addr = 18446744073709545802LLU; // 99999998jJ'''''''''''''''
90328	90639	break;
90329	90640	}
90330		- case 18446744073709545817LLU: // 99999998jY'''''''''''''''
	90641	+ case 18446744073709545802LLU: // 99999998jJ'''''''''''''''
90331	90642	{
90332	90643	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 839030726086098944;
90333	90644
90334		- state.addr = 18446744073709545816LLU; // 99999998jX'''''''''''''''
	90645	+ state.addr = 18446744073709545801LLU; // 99999998jI'''''''''''''''
90335	90646	break;
90336	90647	}
90337		- case 18446744073709545816LLU: // 99999998jX'''''''''''''''
	90648	+ case 18446744073709545801LLU: // 99999998jI'''''''''''''''
90338	90649	{
90339	90650	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90340		- state.addr = 18446744073709545815LLU; // 99999998jW'''''''''''''''
	90651	+ state.addr = 18446744073709545800LLU; // 99999998jH'''''''''''''''
90341	90652	break;
90342	90653	}
90343		- case 18446744073709545815LLU: // 99999998jW'''''''''''''''
	90654	+ case 18446744073709545800LLU: // 99999998jH'''''''''''''''
90344	90655	{
90345		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545814LLU : 18446744073709545813LLU;
	90656	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545799LLU : 18446744073709545798LLU;
90346	90657	break;
90347	90658	}
90348		- case 18446744073709545814LLU: // 99999998jV'''''''''''''''
	90659	+ case 18446744073709545799LLU: // 99999998jG'''''''''''''''
90349	90660	{
90350	90661	// ACCUMULATE ARGUMENTS - BEGIN
90351	90662	{

		@@ -90385,7 +90696,7 @@
90385	90696	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90386	90697	}
90387	90698	// ACCUMULATE ARGUMENTS - END
90388		- uint64_t return_to = 18446744073709545811LLU;
	90699	+ uint64_t return_to = 18446744073709545796LLU;
90389	90700	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
90390	90701	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90391	90702	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90394,43 +90705,43 @@
90394	90705	state.addr = 787472339407601664LLU; // procsize__
90395	90706	break;
90396	90707	}
90397		- case 18446744073709545811LLU: // 99999998jS'''''''''''''''
	90708	+ case 18446744073709545796LLU: // 99999998jD'''''''''''''''
90398	90709	{
90399		- state.addr = 18446744073709545812LLU; // 99999998jT'''''''''''''''
	90710	+ state.addr = 18446744073709545797LLU; // 99999998jE'''''''''''''''
90400	90711	break;
90401	90712	}
90402		- case 18446744073709545812LLU: // 99999998jT'''''''''''''''
	90713	+ case 18446744073709545797LLU: // 99999998jE'''''''''''''''
90403	90714	{
90404	90715	heap.availilable_size_for_dynamic_objects += 0LLU;
90405	90716	heap.availilable_size_for_dynamic_objects += 0LLU;
90406		- state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
	90717	+ state.addr = 18446744073709545795LLU; // 99999998jC'''''''''''''''
90407	90718	break;
90408	90719	}
90409		- case 18446744073709545813LLU: // 99999998jU'''''''''''''''
	90720	+ case 18446744073709545798LLU: // 99999998jF'''''''''''''''
90410	90721	{
90411	90722
90412		- state.addr = 18446744073709545809LLU; // 99999998jQ'''''''''''''''
	90723	+ state.addr = 18446744073709545794LLU; // 99999998jB'''''''''''''''
90413	90724	break;
90414	90725	}
90415		- case 18446744073709545809LLU: // 99999998jQ'''''''''''''''
	90726	+ case 18446744073709545794LLU: // 99999998jB'''''''''''''''
90416	90727	{
90417	90728	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 842862180511514624;
90418	90729
90419		- state.addr = 18446744073709545808LLU; // 99999998jP'''''''''''''''
	90730	+ state.addr = 18446744073709545793LLU; // 99999998jA'''''''''''''''
90420	90731	break;
90421	90732	}
90422		- case 18446744073709545808LLU: // 99999998jP'''''''''''''''
	90733	+ case 18446744073709545793LLU: // 99999998jA'''''''''''''''
90423	90734	{
90424	90735	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90425		- state.addr = 18446744073709545807LLU; // 99999998jO'''''''''''''''
	90736	+ state.addr = 18446744073709545792LLU; // 99999998j_'''''''''''''''
90426	90737	break;
90427	90738	}
90428		- case 18446744073709545807LLU: // 99999998jO'''''''''''''''
	90739	+ case 18446744073709545792LLU: // 99999998j_'''''''''''''''
90429	90740	{
90430		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545806LLU : 18446744073709545805LLU;
	90741	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545791LLU : 18446744073709545790LLU;
90431	90742	break;
90432	90743	}
90433		- case 18446744073709545806LLU: // 99999998jN'''''''''''''''
	90744	+ case 18446744073709545791LLU: // 99999998i9'''''''''''''''
90434	90745	{
90435	90746	// ACCUMULATE ARGUMENTS - BEGIN
90436	90747	{

		@@ -90474,7 +90785,7 @@
90474	90785	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90475	90786	}
90476	90787	// ACCUMULATE ARGUMENTS - END
90477		- uint64_t return_to = 18446744073709545803LLU;
	90788	+ uint64_t return_to = 18446744073709545788LLU;
90478	90789	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0));
90479	90790	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90480	90791	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90483,43 +90794,43 @@
90483	90794	state.addr = 787472339635974144LLU; // procswap__
90484	90795	break;
90485	90796	}
90486		- case 18446744073709545803LLU: // 99999998jK'''''''''''''''
	90797	+ case 18446744073709545788LLU: // 99999998i6'''''''''''''''
90487	90798	{
90488		- state.addr = 18446744073709545804LLU; // 99999998jL'''''''''''''''
	90799	+ state.addr = 18446744073709545789LLU; // 99999998i7'''''''''''''''
90489	90800	break;
90490	90801	}
90491		- case 18446744073709545804LLU: // 99999998jL'''''''''''''''
	90802	+ case 18446744073709545789LLU: // 99999998i7'''''''''''''''
90492	90803	{
90493	90804	heap.availilable_size_for_dynamic_objects += 0LLU;
90494	90805	heap.availilable_size_for_dynamic_objects += 0LLU;
90495		- state.addr = 18446744073709545802LLU; // 99999998jJ'''''''''''''''
	90806	+ state.addr = 18446744073709545787LLU; // 99999998i5'''''''''''''''
90496	90807	break;
90497	90808	}
90498		- case 18446744073709545805LLU: // 99999998jM'''''''''''''''
	90809	+ case 18446744073709545790LLU: // 99999998i8'''''''''''''''
90499	90810	{
90500	90811
90501		- state.addr = 18446744073709545801LLU; // 99999998jI'''''''''''''''
	90812	+ state.addr = 18446744073709545786LLU; // 99999998i4'''''''''''''''
90502	90813	break;
90503	90814	}
90504		- case 18446744073709545801LLU: // 99999998jI'''''''''''''''
	90815	+ case 18446744073709545786LLU: // 99999998i4'''''''''''''''
90505	90816	{
90506	90817	*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 711775449310560256;
90507	90818
90508		- state.addr = 18446744073709545800LLU; // 99999998jH'''''''''''''''
	90819	+ state.addr = 18446744073709545785LLU; // 99999998i3'''''''''''''''
90509	90820	break;
90510	90821	}
90511		- case 18446744073709545800LLU: // 99999998jH'''''''''''''''
	90822	+ case 18446744073709545785LLU: // 99999998i3'''''''''''''''
90512	90823	{
90513	90824	access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU));
90514		- state.addr = 18446744073709545799LLU; // 99999998jG'''''''''''''''
	90825	+ state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
90515	90826	break;
90516	90827	}
90517		- case 18446744073709545799LLU: // 99999998jG'''''''''''''''
	90828	+ case 18446744073709545784LLU: // 99999998i2'''''''''''''''
90518	90829	{
90519		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545798LLU : 18446744073709545797LLU;
	90830	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545783LLU : 18446744073709545782LLU;
90520	90831	break;
90521	90832	}
90522		- case 18446744073709545798LLU: // 99999998jF'''''''''''''''
	90833	+ case 18446744073709545783LLU: // 99999998i1'''''''''''''''
90523	90834	{
90524	90835	// ACCUMULATE ARGUMENTS - BEGIN
90525	90836	{

		@@ -90587,7 +90898,7 @@
90587	90898	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90588	90899	}
90589	90900	// ACCUMULATE ARGUMENTS - END
90590		- uint64_t return_to = 18446744073709545795LLU;
	90901	+ uint64_t return_to = 18446744073709545780LLU;
90591	90902	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0));
90592	90903	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90593	90904	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90596,119 +90907,119 @@
90596	90907	state.addr = 787472331822596096LLU; // proclet___
90597	90908	break;
90598	90909	}
90599		- case 18446744073709545795LLU: // 99999998jC'''''''''''''''
	90910	+ case 18446744073709545780LLU: // 99999998iy'''''''''''''''
90600	90911	{
90601		- state.addr = 18446744073709545796LLU; // 99999998jD'''''''''''''''
	90912	+ state.addr = 18446744073709545781LLU; // 99999998iz'''''''''''''''
90602	90913	break;
90603	90914	}
90604		- case 18446744073709545796LLU: // 99999998jD'''''''''''''''
	90915	+ case 18446744073709545781LLU: // 99999998iz'''''''''''''''
90605	90916	{
90606	90917	heap.availilable_size_for_dynamic_objects += 0LLU;
90607	90918	heap.availilable_size_for_dynamic_objects += 0LLU;
90608		- state.addr = 18446744073709545794LLU; // 99999998jB'''''''''''''''
	90919	+ state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
90609	90920	break;
90610	90921	}
90611		- case 18446744073709545797LLU: // 99999998jE'''''''''''''''
	90922	+ case 18446744073709545782LLU: // 99999998i0'''''''''''''''
90612	90923	{
90613		- state.addr = 18446744073709545794LLU; // 99999998jB'''''''''''''''
	90924	+ state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
90614	90925	break;
90615	90926	}
90616		- case 18446744073709545794LLU: // 99999998jB'''''''''''''''
	90927	+ case 18446744073709545779LLU: // 99999998ix'''''''''''''''
90617	90928	{
90618		- state.addr = 18446744073709545802LLU; // 99999998jJ'''''''''''''''
	90929	+ state.addr = 18446744073709545787LLU; // 99999998i5'''''''''''''''
90619	90930	break;
90620	90931	}
90621		- case 18446744073709545802LLU: // 99999998jJ'''''''''''''''
	90932	+ case 18446744073709545787LLU: // 99999998i5'''''''''''''''
90622	90933	{
90623		- state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
	90934	+ state.addr = 18446744073709545795LLU; // 99999998jC'''''''''''''''
90624	90935	break;
90625	90936	}
90626		- case 18446744073709545810LLU: // 99999998jR'''''''''''''''
	90937	+ case 18446744073709545795LLU: // 99999998jC'''''''''''''''
90627	90938	{
90628		- state.addr = 18446744073709545818LLU; // 99999998jZ'''''''''''''''
	90939	+ state.addr = 18446744073709545803LLU; // 99999998jK'''''''''''''''
90629	90940	break;
90630	90941	}
90631		- case 18446744073709545818LLU: // 99999998jZ'''''''''''''''
	90942	+ case 18446744073709545803LLU: // 99999998jK'''''''''''''''
90632	90943	{
90633		- state.addr = 18446744073709545826LLU; // 99999998jg'''''''''''''''
	90944	+ state.addr = 18446744073709545811LLU; // 99999998jS'''''''''''''''
90634	90945	break;
90635	90946	}
90636		- case 18446744073709545826LLU: // 99999998jg'''''''''''''''
	90947	+ case 18446744073709545811LLU: // 99999998jS'''''''''''''''
90637	90948	{
90638		- state.addr = 18446744073709545834LLU; // 99999998jo'''''''''''''''
	90949	+ state.addr = 18446744073709545819LLU; // 99999998j$'''''''''''''''
90639	90950	break;
90640	90951	}
90641		- case 18446744073709545834LLU: // 99999998jo'''''''''''''''
	90952	+ case 18446744073709545819LLU: // 99999998j$'''''''''''''''
90642	90953	{
90643		- state.addr = 18446744073709545842LLU; // 99999998jw'''''''''''''''
	90954	+ state.addr = 18446744073709545827LLU; // 99999998jh'''''''''''''''
90644	90955	break;
90645	90956	}
90646		- case 18446744073709545842LLU: // 99999998jw'''''''''''''''
	90957	+ case 18446744073709545827LLU: // 99999998jh'''''''''''''''
90647	90958	{
90648		- state.addr = 18446744073709545850LLU; // 99999998j4'''''''''''''''
	90959	+ state.addr = 18446744073709545835LLU; // 99999998jp'''''''''''''''
90649	90960	break;
90650	90961	}
90651		- case 18446744073709545850LLU: // 99999998j4'''''''''''''''
	90962	+ case 18446744073709545835LLU: // 99999998jp'''''''''''''''
90652	90963	{
90653		- state.addr = 18446744073709545858LLU; // 99999998kB'''''''''''''''
	90964	+ state.addr = 18446744073709545843LLU; // 99999998jx'''''''''''''''
90654	90965	break;
90655	90966	}
90656		- case 18446744073709545858LLU: // 99999998kB'''''''''''''''
	90967	+ case 18446744073709545843LLU: // 99999998jx'''''''''''''''
90657	90968	{
90658		- state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
	90969	+ state.addr = 18446744073709545851LLU; // 99999998j5'''''''''''''''
90659	90970	break;
90660	90971	}
90661		- case 18446744073709545866LLU: // 99999998kJ'''''''''''''''
	90972	+ case 18446744073709545851LLU: // 99999998j5'''''''''''''''
90662	90973	{
90663		- state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
	90974	+ state.addr = 18446744073709545859LLU; // 99999998kC'''''''''''''''
90664	90975	break;
90665	90976	}
90666		- case 18446744073709545874LLU: // 99999998kR'''''''''''''''
	90977	+ case 18446744073709545859LLU: // 99999998kC'''''''''''''''
90667	90978	{
90668		- state.addr = 18446744073709545882LLU; // 99999998kZ'''''''''''''''
	90979	+ state.addr = 18446744073709545867LLU; // 99999998kK'''''''''''''''
90669	90980	break;
90670	90981	}
90671		- case 18446744073709545882LLU: // 99999998kZ'''''''''''''''
	90982	+ case 18446744073709545867LLU: // 99999998kK'''''''''''''''
90672	90983	{
90673		- state.addr = 18446744073709545890LLU; // 99999998kg'''''''''''''''
	90984	+ state.addr = 18446744073709545875LLU; // 99999998kS'''''''''''''''
90674	90985	break;
90675	90986	}
90676		- case 18446744073709545890LLU: // 99999998kg'''''''''''''''
	90987	+ case 18446744073709545875LLU: // 99999998kS'''''''''''''''
90677	90988	{
90678		- state.addr = 18446744073709545898LLU; // 99999998ko'''''''''''''''
	90989	+ state.addr = 18446744073709545883LLU; // 99999998k$'''''''''''''''
90679	90990	break;
90680	90991	}
90681		- case 18446744073709545898LLU: // 99999998ko'''''''''''''''
	90992	+ case 18446744073709545883LLU: // 99999998k$'''''''''''''''
90682	90993	{
90683		- state.addr = 18446744073709545906LLU; // 99999998kw'''''''''''''''
	90994	+ state.addr = 18446744073709545891LLU; // 99999998kh'''''''''''''''
90684	90995	break;
90685	90996	}
90686		- case 18446744073709545906LLU: // 99999998kw'''''''''''''''
	90997	+ case 18446744073709545891LLU: // 99999998kh'''''''''''''''
90687	90998	{
90688		- state.addr = 18446744073709545914LLU; // 99999998k4'''''''''''''''
	90999	+ state.addr = 18446744073709545899LLU; // 99999998kp'''''''''''''''
90689	91000	break;
90690	91001	}
90691		- case 18446744073709545914LLU: // 99999998k4'''''''''''''''
	91002	+ case 18446744073709545899LLU: // 99999998kp'''''''''''''''
90692	91003	{
90693		- state.addr = 18446744073709545922LLU; // 99999998lB'''''''''''''''
	91004	+ state.addr = 18446744073709545907LLU; // 99999998kx'''''''''''''''
90694	91005	break;
90695	91006	}
90696		- case 18446744073709545922LLU: // 99999998lB'''''''''''''''
	91007	+ case 18446744073709545907LLU: // 99999998kx'''''''''''''''
90697	91008	{
90698		- state.addr = 18446744073709545930LLU; // 99999998lJ'''''''''''''''
	91009	+ state.addr = 18446744073709545915LLU; // 99999998k5'''''''''''''''
90699	91010	break;
90700	91011	}
90701		- case 18446744073709545930LLU: // 99999998lJ'''''''''''''''
	91012	+ case 18446744073709545915LLU: // 99999998k5'''''''''''''''
90702	91013	{
90703		- state.addr = 18446744073709545938LLU; // 99999998lR'''''''''''''''
	91014	+ state.addr = 18446744073709545923LLU; // 99999998lC'''''''''''''''
90704	91015	break;
90705	91016	}
90706		- case 18446744073709545938LLU: // 99999998lR'''''''''''''''
	91017	+ case 18446744073709545923LLU: // 99999998lC'''''''''''''''
90707	91018	{
90708		- state.addr = 18446744073709545946LLU; // 99999998lZ'''''''''''''''
	91019	+ state.addr = 18446744073709545931LLU; // 99999998lK'''''''''''''''
90709	91020	break;
90710	91021	}
90711		- case 18446744073709545946LLU: // 99999998lZ'''''''''''''''
	91022	+ case 18446744073709545931LLU: // 99999998lK'''''''''''''''
90712	91023	{
90713	91024	// variable u64 sym_______ goes out of scope
90714	91025	// emitted destructur for type u64

		@@ -90769,21 +91080,21 @@
90769	91080	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
90770	91081	}
90771	91082	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /sym_______/LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
90772		- state.addr = 18446744073709545791LLU; // 99999998i9'''''''''''''''
	91083	+ state.addr = 18446744073709545776LLU; // 99999998iu'''''''''''''''
90773	91084	break;
90774	91085	}
90775		- case 18446744073709545791LLU: // 99999998i9'''''''''''''''
	91086	+ case 18446744073709545776LLU: // 99999998iu'''''''''''''''
90776	91087	{
90777		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545793LLU : 18446744073709545792LLU;
	91088	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545778LLU : 18446744073709545777LLU;
90778	91089	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
90779	91090	break;
90780	91091	}
90781		- case 18446744073709545793LLU: // 99999998jA'''''''''''''''
	91092	+ case 18446744073709545778LLU: // 99999998iw'''''''''''''''
90782	91093	{
90783		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709545790LLU : 18446744073709545789LLU;
	91094	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709545775LLU : 18446744073709545774LLU;
90784	91095	break;
90785	91096	}
90786		- case 18446744073709545790LLU: // 99999998i8'''''''''''''''
	91097	+ case 18446744073709545775LLU: // 99999998it'''''''''''''''
90787	91098	{
90788	91099	fprintf(stderr, "%s", "function ");
90789	91100	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)));

		@@ -90792,20 +91103,20 @@
90792	91103	fprintf(stderr, "%s\n", "");
90793	91104	exit(-1);
90794	91105	}
90795		- state.addr = 18446744073709545789LLU; // 99999998i7'''''''''''''''
	91106	+ state.addr = 18446744073709545774LLU; // 99999998is'''''''''''''''
90796	91107	break;
90797	91108	}
90798		- case 18446744073709545789LLU: // 99999998i7'''''''''''''''
	91109	+ case 18446744073709545774LLU: // 99999998is'''''''''''''''
90799	91110	{
90800		- state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
	91111	+ state.addr = 18446744073709545773LLU; // 99999998ir'''''''''''''''
90801	91112	break;
90802	91113	}
90803		- case 18446744073709545788LLU: // 99999998i6'''''''''''''''
	91114	+ case 18446744073709545773LLU: // 99999998ir'''''''''''''''
90804	91115	{
90805	91116	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) = (uint64_t)getchar();
90806	91117	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) > 255)
90807	91118	{
90808		- state.addr = 18446744073709545787LLU; // 99999998i5'''''''''''''''
	91119	+ state.addr = 18446744073709545772LLU; // 99999998iq'''''''''''''''
90809	91120	break;
90810	91121	}
90811	91122	{

		@@ -90813,24 +91124,24 @@
90813	91124	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
90814	91125	}
90815	91126	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /sym_______/LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
90816		- state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
	91127	+ state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
90817	91128	break;
90818	91129	}
90819		- case 18446744073709545784LLU: // 99999998i2'''''''''''''''
	91130	+ case 18446744073709545769LLU: // 99999998in'''''''''''''''
90820	91131	{
90821		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545786LLU : 18446744073709545785LLU;
	91132	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545771LLU : 18446744073709545770LLU;
90822	91133	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
90823	91134	break;
90824	91135	}
90825		- case 18446744073709545786LLU: // 99999998i4'''''''''''''''
	91136	+ case 18446744073709545771LLU: // 99999998ip'''''''''''''''
90826	91137	{
90827	91138	ungetc(0, stdin);
90828	91139	heap.availilable_size_for_dynamic_objects += 0LLU;
90829	91140	heap.availilable_size_for_dynamic_objects += 0LLU;
90830		- state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
	91141	+ state.addr = 18446744073709545768LLU; // 99999998im'''''''''''''''
90831	91142	break;
90832	91143	}
90833		- case 18446744073709545785LLU: // 99999998i3'''''''''''''''
	91144	+ case 18446744073709545770LLU: // 99999998io'''''''''''''''
90834	91145	{
90835	91146	// ACCUMULATE ARGUMENTS - BEGIN
90836	91147	{

		@@ -90838,7 +91149,7 @@
90838	91149	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90839	91150	}
90840	91151	// ACCUMULATE ARGUMENTS - END
90841		- uint64_t return_to = 18446744073709545781LLU;
	91152	+ uint64_t return_to = 18446744073709545766LLU;
90842	91153	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
90843	91154	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90844	91155	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90847,41 +91158,41 @@
90847	91158	state.addr = 587881343588366336LLU; // emitccode_
90848	91159	break;
90849	91160	}
90850		- case 18446744073709545781LLU: // 99999998iz'''''''''''''''
	91161	+ case 18446744073709545766LLU: // 99999998ik'''''''''''''''
90851	91162	{
90852		- state.addr = 18446744073709545782LLU; // 99999998i0'''''''''''''''
	91163	+ state.addr = 18446744073709545767LLU; // 99999998il'''''''''''''''
90853	91164	break;
90854	91165	}
90855		- case 18446744073709545782LLU: // 99999998i0'''''''''''''''
	91166	+ case 18446744073709545767LLU: // 99999998il'''''''''''''''
90856	91167	{
90857		- state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
	91168	+ state.addr = 18446744073709545768LLU; // 99999998im'''''''''''''''
90858	91169	break;
90859	91170	}
90860		- case 18446744073709545783LLU: // 99999998i1'''''''''''''''
	91171	+ case 18446744073709545768LLU: // 99999998im'''''''''''''''
90861	91172	{
90862		- state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
	91173	+ state.addr = 18446744073709545773LLU; // 99999998ir'''''''''''''''
90863	91174	break;
90864	91175	}
90865		- case 18446744073709545787LLU: // 99999998i5'''''''''''''''
	91176	+ case 18446744073709545772LLU: // 99999998iq'''''''''''''''
90866	91177	{
90867	91178
90868		- state.addr = 18446744073709545780LLU; // 99999998iy'''''''''''''''
	91179	+ state.addr = 18446744073709545765LLU; // 99999998ij'''''''''''''''
90869	91180	break;
90870	91181	}
90871		- case 18446744073709545780LLU: // 99999998iy'''''''''''''''
	91182	+ case 18446744073709545765LLU: // 99999998ij'''''''''''''''
90872	91183	{
90873	91184	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) = (uint64_t)getchar();
90874		- state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
	91185	+ state.addr = 18446744073709545764LLU; // 99999998ii'''''''''''''''
90875	91186	break;
90876	91187	}
90877		- case 18446744073709545779LLU: // 99999998ix'''''''''''''''
	91188	+ case 18446744073709545764LLU: // 99999998ii'''''''''''''''
90878	91189	{
90879	91190	heap.availilable_size_for_dynamic_objects += 0LLU;
90880	91191	heap.availilable_size_for_dynamic_objects += 0LLU;
90881		- state.addr = 18446744073709545778LLU; // 99999998iw'''''''''''''''
	91192	+ state.addr = 18446744073709545763LLU; // 99999998ih'''''''''''''''
90882	91193	break;
90883	91194	}
90884		- case 18446744073709545792LLU: // 99999998j_'''''''''''''''
	91195	+ case 18446744073709545777LLU: // 99999998iv'''''''''''''''
90885	91196	{
90886	91197	// ACCUMULATE ARGUMENTS - BEGIN
90887	91198	{

		@@ -90889,7 +91200,7 @@
90889	91200	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90890	91201	}
90891	91202	// ACCUMULATE ARGUMENTS - END
90892		- uint64_t return_to = 18446744073709545776LLU;
	91203	+ uint64_t return_to = 18446744073709545761LLU;
90893	91204	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
90894	91205	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90895	91206	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90898,12 +91209,12 @@
90898	91209	state.addr = 819847183515949359LLU; // reportinit
90899	91210	break;
90900	91211	}
90901		- case 18446744073709545776LLU: // 99999998iu'''''''''''''''
	91212	+ case 18446744073709545761LLU: // 99999998if'''''''''''''''
90902	91213	{
90903		- state.addr = 18446744073709545777LLU; // 99999998iv'''''''''''''''
	91214	+ state.addr = 18446744073709545762LLU; // 99999998ig'''''''''''''''
90904	91215	break;
90905	91216	}
90906		- case 18446744073709545777LLU: // 99999998iv'''''''''''''''
	91217	+ case 18446744073709545762LLU: // 99999998ig'''''''''''''''
90907	91218	{
90908	91219	fprintf(stderr, "%s", "INTERNAL ERROR: expected '`' but found ");
90909	91220	putc((char)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)), stderr);

		@@ -90911,10 +91222,10 @@
90911	91222	fprintf(stderr, "%s\n", "");
90912	91223	exit(-1);
90913	91224	}
90914		- state.addr = 18446744073709545778LLU; // 99999998iw'''''''''''''''
	91225	+ state.addr = 18446744073709545763LLU; // 99999998ih'''''''''''''''
90915	91226	break;
90916	91227	}
90917		- case 18446744073709545778LLU: // 99999998iw'''''''''''''''
	91228	+ case 18446744073709545763LLU: // 99999998ih'''''''''''''''
90918	91229	{
90919	91230	// variable u64 sym_______ goes out of scope
90920	91231	// emitted destructur for type u64

		@@ -90939,15 +91250,15 @@
90939	91250	}
90940	91251	case 782701543301228454LLU: // parseblock
90941	91252	{
90942		- state.addr = 18446744073709545775LLU; // 99999998it'''''''''''''''
	91253	+ state.addr = 18446744073709545760LLU; // 99999998ie'''''''''''''''
90943	91254	break;
90944	91255	}
90945		- case 18446744073709545775LLU: // 99999998it'''''''''''''''
	91256	+ case 18446744073709545760LLU: // 99999998ie'''''''''''''''
90946	91257	{
90947	91258	access_heap(heap.data, LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) = (uint64_t)getchar();
90948	91259	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) > 255)
90949	91260	{
90950		- state.addr = 18446744073709545774LLU; // 99999998is'''''''''''''''
	91261	+ state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
90951	91262	break;
90952	91263	}
90953	91264	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -90956,7 +91267,7 @@
90956	91267	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
90957	91268	}
90958	91269	// ACCUMULATE ARGUMENTS - END
90959		- uint64_t return_to = 18446744073709545772LLU;
	91270	+ uint64_t return_to = 18446744073709545757LLU;
90960	91271	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
90961	91272	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
90962	91273	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -90965,12 +91276,12 @@
90965	91276	state.addr = 839519665163075584LLU; // skip______
90966	91277	break;
90967	91278	}
90968		- case 18446744073709545772LLU: // 99999998iq'''''''''''''''
	91279	+ case 18446744073709545757LLU: // 99999998ib'''''''''''''''
90969	91280	{
90970		- state.addr = 18446744073709545773LLU; // 99999998ir'''''''''''''''
	91281	+ state.addr = 18446744073709545758LLU; // 99999998ic'''''''''''''''
90971	91282	break;
90972	91283	}
90973		- case 18446744073709545773LLU: // 99999998ir'''''''''''''''
	91284	+ case 18446744073709545758LLU: // 99999998ic'''''''''''''''
90974	91285	{
90975	91286	{
90976	91287	uint64_t arg = 0;

		@@ -90982,16 +91293,16 @@
90982	91293	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
90983	91294	}
90984	91295	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 5LLU));
90985		- state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
	91296	+ state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
90986	91297	break;
90987	91298	}
90988		- case 18446744073709545769LLU: // 99999998in'''''''''''''''
	91299	+ case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
90989	91300	{
90990		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545771LLU : 18446744073709545770LLU;
	91301	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545756LLU : 18446744073709545755LLU;
90991	91302	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
90992	91303	break;
90993	91304	}
90994		- case 18446744073709545771LLU: // 99999998ip'''''''''''''''
	91305	+ case 18446744073709545756LLU: // 99999998ia'''''''''''''''
90995	91306	{
90996	91307	// ACCUMULATE ARGUMENTS - BEGIN
90997	91308	{

		@@ -91015,7 +91326,7 @@
91015	91326	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91016	91327	}
91017	91328	// ACCUMULATE ARGUMENTS - END
91018		- uint64_t return_to = 18446744073709545767LLU;
	91329	+ uint64_t return_to = 18446744073709545752LLU;
91019	91330	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
91020	91331	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91021	91332	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91024,19 +91335,19 @@
91024	91335	state.addr = 552446626445785088LLU; // copyccode_
91025	91336	break;
91026	91337	}
91027		- case 18446744073709545767LLU: // 99999998il'''''''''''''''
	91338	+ case 18446744073709545752LLU: // 99999998iX'''''''''''''''
91028	91339	{
91029		- state.addr = 18446744073709545768LLU; // 99999998im'''''''''''''''
	91340	+ state.addr = 18446744073709545753LLU; // 99999998iY'''''''''''''''
91030	91341	break;
91031	91342	}
91032		- case 18446744073709545768LLU: // 99999998im'''''''''''''''
	91343	+ case 18446744073709545753LLU: // 99999998iY'''''''''''''''
91033	91344	{
91034	91345	heap.availilable_size_for_dynamic_objects += 0LLU;
91035	91346	heap.availilable_size_for_dynamic_objects += 0LLU;
91036		- state.addr = 18446744073709545766LLU; // 99999998ik'''''''''''''''
	91347	+ state.addr = 18446744073709545751LLU; // 99999998iW'''''''''''''''
91037	91348	break;
91038	91349	}
91039		- case 18446744073709545770LLU: // 99999998io'''''''''''''''
	91350	+ case 18446744073709545755LLU: // 99999998i$'''''''''''''''
91040	91351	{
91041	91352	{
91042	91353	uint64_t arg = 0;

		@@ -91052,7 +91363,7 @@
91052	91363	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91053	91364	}
91054	91365	// ACCUMULATE ARGUMENTS - END
91055		- uint64_t return_to = 18446744073709545762LLU;
	91366	+ uint64_t return_to = 18446744073709545747LLU;
91056	91367	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
91057	91368	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91058	91369	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91061,18 +91372,18 @@
91061	91372	state.addr = 661610008740528128LLU; // isequsym__
91062	91373	break;
91063	91374	}
91064		- case 18446744073709545762LLU: // 99999998ig'''''''''''''''
	91375	+ case 18446744073709545747LLU: // 99999998iS'''''''''''''''
91065	91376	{
91066		- state.addr = 18446744073709545763LLU; // 99999998ih'''''''''''''''
	91377	+ state.addr = 18446744073709545748LLU; // 99999998iT'''''''''''''''
91067	91378	break;
91068	91379	}
91069		- case 18446744073709545763LLU: // 99999998ih'''''''''''''''
	91380	+ case 18446744073709545748LLU: // 99999998iT'''''''''''''''
91070	91381	{
91071		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545765LLU : 18446744073709545764LLU;
	91382	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545750LLU : 18446744073709545749LLU;
91072	91383	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
91073	91384	break;
91074	91385	}
91075		- case 18446744073709545765LLU: // 99999998ij'''''''''''''''
	91386	+ case 18446744073709545750LLU: // 99999998iV'''''''''''''''
91076	91387	{
91077	91388	matchid("==", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 5LLU)));
91078	91389	{

		@@ -91080,10 +91391,10 @@
91080	91391	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
91081	91392	}
91082	91393	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)));
91083		- state.addr = 18446744073709545761LLU; // 99999998if'''''''''''''''
	91394	+ state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
91084	91395	break;
91085	91396	}
91086		- case 18446744073709545761LLU: // 99999998if'''''''''''''''
	91397	+ case 18446744073709545746LLU: // 99999998iR'''''''''''''''
91087	91398	{
91088	91399	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 5LLU)), stdin);
91089	91400	if('=' != (char)getchar())

		@@ -91101,22 +91412,22 @@
91101	91412	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
91102	91413	}
91103	91414	LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /defargcnt_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 12LLU)) + /defbodysz_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 13LLU));
91104		- state.addr = 18446744073709545760LLU; // 99999998ie'''''''''''''''
	91415	+ state.addr = 18446744073709545745LLU; // 99999998iQ'''''''''''''''
91105	91416	break;
91106	91417	}
91107		- case 18446744073709545760LLU: // 99999998ie'''''''''''''''
	91418	+ case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
91108	91419	{
91109	91420
91110		- state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
	91421	+ state.addr = 18446744073709545744LLU; // 99999998iP'''''''''''''''
91111	91422	break;
91112	91423	}
91113		- case 18446744073709545759LLU: // 99999998id'''''''''''''''
	91424	+ case 18446744073709545744LLU: // 99999998iP'''''''''''''''
91114	91425	{
91115	91426	LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /bufB______/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) - /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 14LLU));
91116		- state.addr = 18446744073709545758LLU; // 99999998ic'''''''''''''''
	91427	+ state.addr = 18446744073709545743LLU; // 99999998iO'''''''''''''''
91117	91428	break;
91118	91429	}
91119		- case 18446744073709545758LLU: // 99999998ic'''''''''''''''
	91430	+ case 18446744073709545743LLU: // 99999998iO'''''''''''''''
91120	91431	{
91121	91432	{
91122	91433	uint64_t arg = 0;

		@@ -91123,16 +91434,16 @@
91123	91434	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
91124	91435	}
91125	91436	LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /level_____/LOCAL_ACCESS(heap.data, 20LLU, 17LLU) != /bufB______/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU);
91126		- state.addr = 18446744073709545755LLU; // 99999998i$'''''''''''''''
	91437	+ state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
91127	91438	break;
91128	91439	}
91129		- case 18446744073709545755LLU: // 99999998i$'''''''''''''''
	91440	+ case 18446744073709545740LLU: // 99999998iL'''''''''''''''
91130	91441	{
91131		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545757LLU : 18446744073709545756LLU;
	91442	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545742LLU : 18446744073709545741LLU;
91132	91443	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
91133	91444	break;
91134	91445	}
91135		- case 18446744073709545757LLU: // 99999998ib'''''''''''''''
	91446	+ case 18446744073709545742LLU: // 99999998iN'''''''''''''''
91136	91447	{
91137	91448	// ACCUMULATE ARGUMENTS - BEGIN
91138	91449	{

		@@ -91140,7 +91451,7 @@
91140	91451	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91141	91452	}
91142	91453	// ACCUMULATE ARGUMENTS - END
91143		- uint64_t return_to = 18446744073709545753LLU;
	91454	+ uint64_t return_to = 18446744073709545738LLU;
91144	91455	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
91145	91456	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91146	91457	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91149,12 +91460,12 @@
91149	91460	state.addr = 819847183515949359LLU; // reportinit
91150	91461	break;
91151	91462	}
91152		- case 18446744073709545753LLU: // 99999998iY'''''''''''''''
	91463	+ case 18446744073709545738LLU: // 99999998iJ'''''''''''''''
91153	91464	{
91154		- state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
	91465	+ state.addr = 18446744073709545739LLU; // 99999998iK'''''''''''''''
91155	91466	break;
91156	91467	}
91157		- case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
	91468	+ case 18446744073709545739LLU: // 99999998iK'''''''''''''''
91158	91469	{
91159	91470	fprintf(stderr, "%s", "expected specified level ");
91160	91471	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -91163,7 +91474,7 @@
91163	91474	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91164	91475	}
91165	91476	// ACCUMULATE ARGUMENTS - END
91166		- uint64_t return_to = 18446744073709545751LLU;
	91477	+ uint64_t return_to = 18446744073709545736LLU;
91167	91478	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
91168	91479	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91169	91480	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91172,12 +91483,12 @@
91172	91483	state.addr = 819847183517274112LLU; // reportnr__
91173	91484	break;
91174	91485	}
91175		- case 18446744073709545751LLU: // 99999998iW'''''''''''''''
	91486	+ case 18446744073709545736LLU: // 99999998iH'''''''''''''''
91176	91487	{
91177		- state.addr = 18446744073709545752LLU; // 99999998iX'''''''''''''''
	91488	+ state.addr = 18446744073709545737LLU; // 99999998iI'''''''''''''''
91178	91489	break;
91179	91490	}
91180		- case 18446744073709545752LLU: // 99999998iX'''''''''''''''
	91491	+ case 18446744073709545737LLU: // 99999998iI'''''''''''''''
91181	91492	{
91182	91493	fprintf(stderr, "%s", " but found actual level ");
91183	91494	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -91186,7 +91497,7 @@
91186	91497	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91187	91498	}
91188	91499	// ACCUMULATE ARGUMENTS - END
91189		- uint64_t return_to = 18446744073709545749LLU;
	91500	+ uint64_t return_to = 18446744073709545734LLU;
91190	91501	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
91191	91502	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91192	91503	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91195,21 +91506,21 @@
91195	91506	state.addr = 819847183517274112LLU; // reportnr__
91196	91507	break;
91197	91508	}
91198		- case 18446744073709545749LLU: // 99999998iU'''''''''''''''
	91509	+ case 18446744073709545734LLU: // 99999998iF'''''''''''''''
91199	91510	{
91200		- state.addr = 18446744073709545750LLU; // 99999998iV'''''''''''''''
	91511	+ state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
91201	91512	break;
91202	91513	}
91203		- case 18446744073709545750LLU: // 99999998iV'''''''''''''''
	91514	+ case 18446744073709545735LLU: // 99999998iG'''''''''''''''
91204	91515	{
91205	91516	{
91206	91517	fprintf(stderr, "%s\n", "");
91207	91518	exit(-1);
91208	91519	}
91209		- state.addr = 18446744073709545756LLU; // 99999998ia'''''''''''''''
	91520	+ state.addr = 18446744073709545741LLU; // 99999998iM'''''''''''''''
91210	91521	break;
91211	91522	}
91212		- case 18446744073709545756LLU: // 99999998ia'''''''''''''''
	91523	+ case 18446744073709545741LLU: // 99999998iM'''''''''''''''
91213	91524	{
91214	91525	// variable u64 bufB______ goes out of scope
91215	91526	// emitted destructur for type u64

		@@ -91219,16 +91530,16 @@
91219	91530	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 18
91220	91531	heap.availilable_size_for_dynamic_objects += 0LLU;
91221	91532	heap.availilable_size_for_dynamic_objects += 0LLU;
91222		- state.addr = 18446744073709545748LLU; // 99999998iT'''''''''''''''
	91533	+ state.addr = 18446744073709545733LLU; // 99999998iE'''''''''''''''
91223	91534	break;
91224	91535	}
91225		- case 18446744073709545764LLU: // 99999998ii'''''''''''''''
	91536	+ case 18446744073709545749LLU: // 99999998iU'''''''''''''''
91226	91537	{
91227	91538
91228		- state.addr = 18446744073709545747LLU; // 99999998iS'''''''''''''''
	91539	+ state.addr = 18446744073709545732LLU; // 99999998iD'''''''''''''''
91229	91540	break;
91230	91541	}
91231		- case 18446744073709545747LLU: // 99999998iS'''''''''''''''
	91542	+ case 18446744073709545732LLU: // 99999998iD'''''''''''''''
91232	91543	{
91233	91544	*LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 123;
91234	91545	{

		@@ -91236,16 +91547,16 @@
91236	91547	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
91237	91548	}
91238	91549	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 5LLU));
91239		- state.addr = 18446744073709545744LLU; // 99999998iP'''''''''''''''
	91550	+ state.addr = 18446744073709545729LLU; // 99999998iA'''''''''''''''
91240	91551	break;
91241	91552	}
91242		- case 18446744073709545744LLU: // 99999998iP'''''''''''''''
	91553	+ case 18446744073709545729LLU: // 99999998iA'''''''''''''''
91243	91554	{
91244		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545746LLU : 18446744073709545745LLU;
	91555	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545731LLU : 18446744073709545730LLU;
91245	91556	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
91246	91557	break;
91247	91558	}
91248		- case 18446744073709545746LLU: // 99999998iR'''''''''''''''
	91559	+ case 18446744073709545731LLU: // 99999998iC'''''''''''''''
91249	91560	{
91250	91561	// ACCUMULATE ARGUMENTS - BEGIN
91251	91562	{

		@@ -91273,7 +91584,7 @@
91273	91584	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
91274	91585	}
91275	91586	// ACCUMULATE ARGUMENTS - END
91276		- uint64_t return_to = 18446744073709545742LLU;
	91587	+ uint64_t return_to = 18446744073709545727LLU;
91277	91588	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
91278	91589	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
91279	91590	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -91282,25 +91593,25 @@
91282	91593	state.addr = 533581901922699840LLU; // blockopen_
91283	91594	break;
91284	91595	}
91285		- case 18446744073709545742LLU: // 99999998iN'''''''''''''''
	91596	+ case 18446744073709545727LLU: // 99999998h9'''''''''''''''
91286	91597	{
91287		- state.addr = 18446744073709545743LLU; // 99999998iO'''''''''''''''
	91598	+ state.addr = 18446744073709545728LLU; // 99999998i_'''''''''''''''
91288	91599	break;
91289	91600	}
91290		- case 18446744073709545743LLU: // 99999998iO'''''''''''''''
	91601	+ case 18446744073709545728LLU: // 99999998i_'''''''''''''''
91291	91602	{
91292	91603	heap.availilable_size_for_dynamic_objects += 0LLU;
91293	91604	heap.availilable_size_for_dynamic_objects += 0LLU;
91294		- state.addr = 18446744073709545741LLU; // 99999998iM'''''''''''''''
	91605	+ state.addr = 18446744073709545726LLU; // 99999998h8'''''''''''''''
91295	91606	break;
91296	91607	}
91297		- case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
	91608	+ case 18446744073709545730LLU: // 99999998iB'''''''''''''''
91298	91609	{
91299	91610
91300		- state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
	91611	+ state.addr = 18446744073709545725LLU; // 99999998h7'''''''''''''''
91301	91612	break;
91302	91613	}
91303		- case 18446744073709545740LLU: // 99999998iL'''''''''''''''
	91614	+ case 18446744073709545725LLU: // 99999998h7'''''''''''''''
91304	91615	{
91305	91616	*LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 125;
91306	91617	{

		@@ -91308,16 +91619,16 @@
91308	91619	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
91309	91620	}
91310	91621	LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 5LLU));
91311		- state.addr = 18446744073709545737LLU; // 99999998iI'''''''''''''''
	91622	+ state.addr = 18446744073709545722LLU; // 99999998h4'''''''''''''''
91312	91623	break;
91313	91624	}
91314		- case 18446744073709545737LLU: // 99999998iI'''''''''''''''
	91625	+ case 18446744073709545722LLU: // 99999998h4'''''''''''''''
91315	91626	{
91316		- state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545739LLU : 18446744073709545738LLU;
	91627	+ state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545724LLU : 18446744073709545723LLU;
91317	91628	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
91318	91629	break;
91319	91630	}
91320		- case 18446744073709545739LLU: // 99999998iK'''''''''''''''
	91631	+ case 18446744073709545724LLU: // 99999998h6'''''''''''''''
91321	91632	{
91322	91633	{
91323	91634	uint64_t arg = /results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 11LLU));

		@@ -91327,10 +91638,10 @@
91327	91638	uint64_t arg = 0;
91328	91639	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
91329	91640	}
91330		- state.addr = 18446744073709545736LLU; // 99999998iH'''''''''''''''
	91641	+ state.addr = 18446744073709545721LLU; // 99999998h3'''''''''''''''
91331	91642	break;
91332	91643	}
91333		- case 18446744073709545736LLU: // 99999998iH'''''''''''''''
	91644	+ case 18446744073709545721LLU: // 99999998h3'''''''''''''''
91334	91645	{
91335	91646	if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU))
91336	91647	{

		@@ -91337,7 +91648,7 @@
91337	91648	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
91338	91649	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
91339	91650	{
91340		- state.addr = 18446744073709545735LLU; // 99999

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

Show on old repository browser