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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	828 (tree)
Time	2019-11-05 07:51:51
Author	jakobthomsen

Log Message

simplify pattern-matching implementation

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 827)

+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 828)

		@@ -94851,10 +94851,14 @@
94851	94851	case 18446744073709546144LLU: // 99999998oe'''''''''''''''
94852	94852	{
94853	94853	{
	94854	+ uint64_t arg = 0LLU;
	94855	+ LOCAL_PUSH_MOVE(&heap, 32, &(heap.data[0].elem1)/address of current closure/, &arg);
	94856	+ }
	94857	+ {
94854	94858	uint64_t mainresult = heap.data[0].elem0;
94855	94859	heap.data[0].elem0 = 0;
94856	94860	{
94857		- uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 32LLU, 4LLU);
	94861	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 33LLU, 4LLU);
94858	94862	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94859	94863	}
94860	94864	// 1LLU

		@@ -94878,11 +94882,11 @@
94878	94882	uint64_t mainresult = heap.data[0].elem0;
94879	94883	heap.data[0].elem0 = 0;
94880	94884	{
94881		- uint64_t arg = /matchsym__/LOCAL_ACCESS_ADDR(heap.data, 32LLU, 24LLU);
	94885	+ uint64_t arg = /matchsym__/LOCAL_ACCESS_ADDR(heap.data, 33LLU, 24LLU);
94882	94886	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94883	94887	}
94884	94888	{
94885		- uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 32LLU, 4LLU);
	94889	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 33LLU, 4LLU);
94886	94890	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94887	94891	}
94888	94892	// 2LLU

		@@ -94892,7 +94896,7 @@
94892	94896	heap.data[0].elem1 = heap.data[0].elem0;
94893	94897	heap.data[0].elem0 = mainresult;
94894	94898	}
94895		- state.addr = 661605045736570880LLU; // isdigit___
	94899	+ state.addr = 661592067397386240LLU; // isalpha___
94896	94900	break;
94897	94901	}
94898	94902	case 18446744073709546138LLU: // 99999998oZ'''''''''''''''

		@@ -94902,20 +94906,42 @@
94902	94906	}
94903	94907	case 18446744073709546139LLU: // 99999998o$'''''''''''''''
94904	94908	{
94905		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 32LLU, 24LLU) ? 18446744073709546137LLU : 18446744073709546136LLU;
	94909	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 33LLU, 24LLU) ? 18446744073709546137LLU : 18446744073709546136LLU;
94906	94910	break;
94907	94911	}
94908	94912	case 18446744073709546137LLU: // 99999998oY'''''''''''''''
94909	94913	{
	94914	+ /parid_____/LOCAL_ACCESS(heap.data, 33LLU, 32LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)));
	94915	+ state.addr = 18446744073709546136LLU; // 99999998oX'''''''''''''''
	94916	+ break;
	94917	+ }
	94918	+ case 18446744073709546136LLU: // 99999998oX'''''''''''''''
	94919	+ {
94910	94920	{
	94921	+ uint64_t arg = /parnr_____/*LOCAL_ACCESS(heap.data, 33LLU, 29LLU);
	94922	+ LOCAL_PUSH_MOVE(&heap, 33, &(heap.data[0].elem1)/address of current closure/, &arg);
	94923	+ }
	94924	+ /paridx____/LOCAL_ACCESS(heap.data, 34LLU, 33LLU) = /paridx____/LOCAL_ACCESS(heap.data, 34LLU, 33LLU) + /returnbase/*LOCAL_ACCESS(heap.data, 34LLU, 26LLU);
	94925	+ {
	94926	+ uint64_t arg = 1LLU;
	94927	+ LOCAL_PUSH_MOVE(&heap, 34, &(heap.data[0].elem1)/address of current closure/, &arg);
	94928	+ }
	94929	+ {
	94930	+ uint64_t arg = 0LLU;
	94931	+ uint64_t constrid = 861504796319285248LLU; // typeu64___
	94932	+ arg = pair_move(&heap, &constrid, &arg);
	94933	+;
	94934	+ LOCAL_PUSH_MOVE(&heap, 35, &(heap.data[0].elem1)/address of current closure/, &arg);
	94935	+ }
	94936	+ {
94911	94937	uint64_t mainresult = heap.data[0].elem0;
94912	94938	heap.data[0].elem0 = 0;
94913	94939	{
94914		- uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 32LLU, 2LLU);
	94940	+ uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 36LLU, 35LLU);
94915	94941	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94916	94942	}
94917	94943	{
94918		- uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 32LLU, 31LLU), 2LLU);
	94944	+ uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 36LLU, 31LLU), 2LLU);
94919	94945	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94920	94946	}
94921	94947	// 2LLU

		@@ -94925,7 +94951,7 @@
94925	94951	heap.data[0].elem1 = heap.data[0].elem0;
94926	94952	heap.data[0].elem0 = mainresult;
94927	94953	}
94928		- state.addr = 517555565476695680LLU; // assertu64_
	94954	+ state.addr = 861504776686223360LLU; // typecopy__
94929	94955	break;
94930	94956	}
94931	94957	case 18446744073709546134LLU: // 99999998oV'''''''''''''''

		@@ -94936,21 +94962,25 @@
94936	94962	case 18446744073709546135LLU: // 99999998oW'''''''''''''''
94937	94963	{
94938	94964	{
	94965	+ uint64_t arg = /sign______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 36LLU, 31LLU), 1LLU));
	94966	+ LOCAL_PUSH_MOVE(&heap, 36, &(heap.data[0].elem1)/address of current closure/, &arg);
	94967	+ }
	94968	+ {
94939	94969	uint64_t arg = 0LLU;
94940		- uint64_t constrid = 861504796319285248LLU; // typeu64___
	94970	+ uint64_t constrid = 728618437845356544LLU; // maintain__
94941	94971	arg = pair_move(&heap, &constrid, &arg);
94942	94972	;
94943		- LOCAL_PUSH_MOVE(&heap, 32, &(heap.data[0].elem1)/address of current closure/, &arg);
	94973	+ LOCAL_PUSH_MOVE(&heap, 37, &(heap.data[0].elem1)/address of current closure/, &arg);
94944	94974	}
94945	94975	{
94946	94976	uint64_t mainresult = heap.data[0].elem0;
94947	94977	heap.data[0].elem0 = 0;
94948	94978	{
94949		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 33LLU, 32LLU);
	94979	+ uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 37LLU);
94950	94980	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94951	94981	}
94952	94982	{
94953		- uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 33LLU, 31LLU), 2LLU);
	94983	+ uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 38LLU, 31LLU), 0LLU);
94954	94984	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94955	94985	}
94956	94986	// 2LLU

		@@ -94960,7 +94990,7 @@
94960	94990	heap.data[0].elem1 = heap.data[0].elem0;
94961	94991	heap.data[0].elem0 = mainresult;
94962	94992	}
94963		- state.addr = 861504776686223360LLU; // typecopy__
	94993	+ state.addr = 552446636209866541LLU; // copylinear
94964	94994	break;
94965	94995	}
94966	94996	case 18446744073709546132LLU: // 99999998oT'''''''''''''''

		@@ -94971,35 +95001,44 @@
94971	95001	case 18446744073709546133LLU: // 99999998oU'''''''''''''''
94972	95002	{
94973	95003	{
94974		- uint64_t arg = /sign______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 33LLU, 31LLU), 1LLU));
94975		- LOCAL_PUSH_MOVE(&heap, 33, &(heap.data[0].elem1)/address of current closure/, &arg);
94976		- }
94977		- {
94978		- uint64_t arg = 0LLU;
94979		- uint64_t constrid = 728618437845356544LLU; // maintain__
94980		- arg = pair_move(&heap, &constrid, &arg);
94981		-;
94982		- LOCAL_PUSH_MOVE(&heap, 34, &(heap.data[0].elem1)/address of current closure/, &arg);
94983		- }
94984		- {
94985	95004	uint64_t mainresult = heap.data[0].elem0;
94986	95005	heap.data[0].elem0 = 0;
94987	95006	{
94988		- uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 35LLU, 34LLU);
	95007	+ uint64_t arg = /varlist___/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 25LLU);
94989	95008	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94990	95009	}
94991	95010	{
94992		- uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 35LLU, 31LLU), 0LLU);
	95011	+ uint64_t arg = /parid_____/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 32LLU);
94993	95012	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
94994	95013	}
94995		- // 2LLU
	95014	+ {
	95015	+ uint64_t arg = /paridx____/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 33LLU);
	95016	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95017	+ }
	95018	+ {
	95019	+ uint64_t arg = /REFERENCE_/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 34LLU);
	95020	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95021	+ }
	95022	+ {
	95023	+ uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 35LLU);
	95024	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95025	+ }
	95026	+ {
	95027	+ uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 36LLU);
	95028	+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95029	+ }
	95030	+ {
	95031	+ uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 37LLU);
	95032	+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95033	+ }
	95034	+ // 7LLU
94996	95035	uint64_t return_to = 18446744073709546130LLU;
94997	95036	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
94998		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95037	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
94999	95038	heap.data[0].elem1 = heap.data[0].elem0;
95000	95039	heap.data[0].elem0 = mainresult;
95001	95040	}
95002		- state.addr = 552446636209866541LLU; // copylinear
	95041	+ state.addr = 788334682132335200LLU; // pushbyline
95003	95042	break;
95004	95043	}
95005	95044	case 18446744073709546130LLU: // 99999998oR'''''''''''''''

		@@ -95009,17 +95048,11 @@
95009	95048	}
95010	95049	case 18446744073709546131LLU: // 99999998oS'''''''''''''''
95011	95050	{
95012		- state.addr = 728618437845356544LLU == heap.data[*LOCAL_ACCESS(heap.data, 35LLU, 34LLU)].elem0 ? 18446744073709546129LLU : 18446744073709546128LLU;
	95051	+ state.addr = /parid_____/*LOCAL_ACCESS(heap.data, 38LLU, 32LLU) ? 18446744073709546129LLU : 18446744073709546128LLU;
95013	95052	break;
95014	95053	}
95015	95054	case 18446744073709546129LLU: // 99999998oQ'''''''''''''''
95016	95055	{
95017		- {
95018		- uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 35LLU, 34LLU)].elem1;
95019		- LOCAL_PUSH_MOVE(&heap, 35, &(heap.data[0].elem1)/address of current closure/, &arg);
95020		- }
95021		- // parameter maintain__ linearity_ goes out of scope
95022		- (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 36
95023	95056	heap.availilable_size_for_dynamic_objects += 0LLU;
95024	95057	heap.availilable_size_for_dynamic_objects += 0LLU;
95025	95058	state.addr = 18446744073709546127LLU; // 99999998oO'''''''''''''''

		@@ -95027,635 +95060,382 @@
95027	95060	}
95028	95061	case 18446744073709546128LLU: // 99999998oP'''''''''''''''
95029	95062	{
95030		- state.addr = 552437437528276992LLU == heap.data[*LOCAL_ACCESS(heap.data, 35LLU, 34LLU)].elem0 ? 18446744073709546126LLU : 18446744073709546125LLU;
95031		- break;
95032		- }
95033		- case 18446744073709546126LLU: // 99999998oN'''''''''''''''
95034		- {
	95063	+ /simple____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 38LLU, 13LLU)) = 0LLU;
	95064	+
95035	95065	{
95036		- uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 35LLU, 34LLU)].elem1;
95037		- LOCAL_PUSH_MOVE(&heap, 35, &(heap.data[0].elem1)/address of current closure/, &arg);
95038		- }
95039		- // parameter consume___ linearity_ goes out of scope
95040		- (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 36
95041		- heap.availilable_size_for_dynamic_objects += 0LLU;
95042		- heap.availilable_size_for_dynamic_objects += 0LLU;
95043		- state.addr = 18446744073709546124LLU; // 99999998oL'''''''''''''''
95044		- break;
95045		- }
95046		- case 18446744073709546125LLU: // 99999998oM'''''''''''''''
95047		- {
95048		- {
95049	95066	uint64_t mainresult = heap.data[0].elem0;
95050	95067	heap.data[0].elem0 = 0;
95051	95068	{
95052		- uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 35LLU, 2LLU);
	95069	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 38LLU, 4LLU);
95053	95070	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95054	95071	}
95055	95072	// 1LLU
95056		- uint64_t return_to = 18446744073709546122LLU;
	95073	+ uint64_t return_to = 18446744073709546125LLU;
95057	95074	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95058	95075	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95059	95076	heap.data[0].elem1 = heap.data[0].elem0;
95060	95077	heap.data[0].elem0 = mainresult;
95061	95078	}
95062		- state.addr = 819847183515949359LLU; // reportinit
	95079	+ state.addr = 839519719621918720LLU; // skipws____
95063	95080	break;
95064	95081	}
95065		- case 18446744073709546122LLU: // 99999998oJ'''''''''''''''
	95082	+ case 18446744073709546125LLU: // 99999998oM'''''''''''''''
95066	95083	{
95067		- state.addr = 18446744073709546123LLU; // 99999998oK'''''''''''''''
	95084	+ state.addr = 18446744073709546126LLU; // 99999998oN'''''''''''''''
95068	95085	break;
95069	95086	}
95070		- case 18446744073709546123LLU: // 99999998oK'''''''''''''''
	95087	+ case 18446744073709546126LLU: // 99999998oN'''''''''''''''
95071	95088	{
95072		- fprintf(stderr, "%s", "can't match 0 with ");
95073	95089	{
95074	95090	uint64_t mainresult = heap.data[0].elem0;
95075	95091	heap.data[0].elem0 = 0;
95076	95092	{
95077		- uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 35LLU, 34LLU);
	95093	+ uint64_t arg = /matchsym__/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 24LLU);
95078	95094	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95079	95095	}
95080		- // 1LLU
95081		- uint64_t return_to = 18446744073709546120LLU;
	95096	+ {
	95097	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 38LLU, 4LLU);
	95098	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95099	+ }
	95100	+ // 2LLU
	95101	+ uint64_t return_to = 18446744073709546123LLU;
95082	95102	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95083		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95103	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95084	95104	heap.data[0].elem1 = heap.data[0].elem0;
95085	95105	heap.data[0].elem0 = mainresult;
95086	95106	}
95087		- state.addr = 819847183516715616LLU; // reportline
	95107	+ state.addr = 661605045736570880LLU; // isdigit___
95088	95108	break;
95089	95109	}
95090		- case 18446744073709546120LLU: // 99999998oH'''''''''''''''
	95110	+ case 18446744073709546123LLU: // 99999998oK'''''''''''''''
95091	95111	{
95092		- state.addr = 18446744073709546121LLU; // 99999998oI'''''''''''''''
95093		- break;
95094		- }
95095		- case 18446744073709546121LLU: // 99999998oI'''''''''''''''
95096		- {
95097		- fprintf(stderr, "%s", " ");
95098		- fprintf(stderr, "%llu", (unsigned long long)/parnr_____/*LOCAL_ACCESS(heap.data, 35LLU, 29LLU));
95099		- fprintf(stderr, "%s", " parameter");
95100		- {
95101		- fprintf(stderr, "%s\n", "");
95102		- exit(-1);
95103		- }
95104	95112	state.addr = 18446744073709546124LLU; // 99999998oL'''''''''''''''
95105	95113	break;
95106	95114	}
95107	95115	case 18446744073709546124LLU: // 99999998oL'''''''''''''''
95108	95116	{
95109		- state.addr = 18446744073709546127LLU; // 99999998oO'''''''''''''''
	95117	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 38LLU, 24LLU) ? 18446744073709546122LLU : 18446744073709546121LLU;
95110	95118	break;
95111	95119	}
95112		- case 18446744073709546127LLU: // 99999998oO'''''''''''''''
	95120	+ case 18446744073709546122LLU: // 99999998oJ'''''''''''''''
95113	95121	{
95114	95122	{
95115		- uint64_t arg = 0LLU;
95116		- LOCAL_PUSH_MOVE(&heap, 35, &(heap.data[0].elem1)/address of current closure/, &arg);
95117		- }
95118		- /val_______/LOCAL_ACCESS(heap.data, 36LLU, 35LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 36LLU, 4LLU)));
95119		- /simple____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 36LLU, 13LLU)) = 0LLU;
95120		-
95121		- {
95122		- uint64_t arg = 0LLU;
95123		- LOCAL_PUSH_MOVE(&heap, 36, &(heap.data[0].elem1)/address of current closure/, &arg);
95124		- }
95125		- {
95126		- uint64_t arg = 1LLU;
95127		- LOCAL_PUSH_MOVE(&heap, 37, &(heap.data[0].elem1)/address of current closure/, &arg);
95128		- }
95129		- {
95130		- uint64_t arg = /parnr_____/*LOCAL_ACCESS(heap.data, 38LLU, 29LLU);
95131		- LOCAL_PUSH_MOVE(&heap, 38, &(heap.data[0].elem1)/address of current closure/, &arg);
95132		- }
95133		- /paridx____/LOCAL_ACCESS(heap.data, 39LLU, 38LLU) = /paridx____/LOCAL_ACCESS(heap.data, 39LLU, 38LLU) + /returnbase/*LOCAL_ACCESS(heap.data, 39LLU, 26LLU);
95134		- {
95135		- uint64_t arg = 1LLU;
95136		- LOCAL_PUSH_MOVE(&heap, 39, &(heap.data[0].elem1)/address of current closure/, &arg);
95137		- }
95138		- {
95139	95123	uint64_t mainresult = heap.data[0].elem0;
95140	95124	heap.data[0].elem0 = 0;
95141	95125	{
95142		- uint64_t arg = /level_____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU);
	95126	+ uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 38LLU, 2LLU);
95143	95127	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95144	95128	}
95145		- // 1LLU
95146		- uint64_t return_to = 18446744073709546114LLU;
95147		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95148		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95149		- heap.data[0].elem1 = heap.data[0].elem0;
95150		- heap.data[0].elem0 = mainresult;
95151		- }
95152		- state.addr = 660197403663532032LLU; // indent____
95153		- break;
95154		- }
95155		- case 18446744073709546114LLU: // 99999998oB'''''''''''''''
95156		- {
95157		- state.addr = 18446744073709546115LLU; // 99999998oC'''''''''''''''
95158		- break;
95159		- }
95160		- case 18446744073709546115LLU: // 99999998oC'''''''''''''''
95161		- {
95162		- fprintf(stdout, "%s", " if(");
95163		- {
95164		- uint64_t mainresult = heap.data[0].elem0;
95165		- heap.data[0].elem0 = 0;
95166	95129	{
95167		- uint64_t arg = /defargcnt_/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 20LLU);
95168		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95169		- }
95170		- {
95171		- uint64_t arg = /defbodysz_/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 21LLU);
	95130	+ uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 38LLU, 31LLU), 2LLU);
95172	95131	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95173	95132	}
95174		- {
95175		- uint64_t arg = /remainsize/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 22LLU);
95176		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95177		- }
95178		- {
95179		- uint64_t arg = /paridx____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 38LLU);
95180		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95181		- }
95182		- // 4LLU
95183		- uint64_t return_to = 18446744073709546112LLU;
	95133	+ // 2LLU
	95134	+ uint64_t return_to = 18446744073709546119LLU;
95184	95135	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95185		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95136	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95186	95137	heap.data[0].elem1 = heap.data[0].elem0;
95187	95138	heap.data[0].elem0 = mainresult;
95188	95139	}
95189		- state.addr = 587881359725559808LLU; // emitref___
	95140	+ state.addr = 517555565476695680LLU; // assertu64_
95190	95141	break;
95191	95142	}
95192		- case 18446744073709546112LLU: // 99999998o_'''''''''''''''
	95143	+ case 18446744073709546119LLU: // 99999998oG'''''''''''''''
95193	95144	{
95194		- state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
	95145	+ state.addr = 18446744073709546120LLU; // 99999998oH'''''''''''''''
95195	95146	break;
95196	95147	}
95197		- case 18446744073709546113LLU: // 99999998oA'''''''''''''''
	95148	+ case 18446744073709546120LLU: // 99999998oH'''''''''''''''
95198	95149	{
95199		- fprintf(stdout, "%s", " != ");
95200		- fprintf(stdout, "%llu", (unsigned long long)/val_______/*LOCAL_ACCESS(heap.data, 40LLU, 35LLU));
95201		- fprintf(stdout, "%s", ")");
95202		- {
95203		- uint64_t mainresult = heap.data[0].elem0;
95204		- heap.data[0].elem0 = 0;
95205		- {
95206		- uint64_t arg = /level_____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU);
95207		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95208		- }
95209		- {
95210		- uint64_t arg = /caseaddr__/*LOCAL_ACCESS(heap.data, 40LLU, 6LLU);
95211		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95212		- }
95213		- // 2LLU
95214		- uint64_t return_to = 18446744073709546110LLU;
95215		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95216		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95217		- heap.data[0].elem1 = heap.data[0].elem0;
95218		- heap.data[0].elem0 = mainresult;
95219		- }
95220		- state.addr = 587881351406075392LLU; // emitjump2_
	95150	+ state.addr = 728618437845356544LLU == heap.data[*LOCAL_ACCESS(heap.data, 38LLU, 37LLU)].elem0 ? 18446744073709546118LLU : 18446744073709546117LLU;
95221	95151	break;
95222	95152	}
95223		- case 18446744073709546110LLU: // 99999998n8'''''''''''''''
	95153	+ case 18446744073709546118LLU: // 99999998oF'''''''''''''''
95224	95154	{
95225		- state.addr = 18446744073709546111LLU; // 99999998n9'''''''''''''''
	95155	+ {
	95156	+ uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 38LLU, 37LLU)].elem1;
	95157	+ LOCAL_PUSH_MOVE(&heap, 38, &(heap.data[0].elem1)/address of current closure/, &arg);
	95158	+ }
	95159	+ // parameter maintain__ linearity_ goes out of scope
	95160	+ (void)LOCAL_POP_MOVE(&heap, 39LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 39
	95161	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95162	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95163	+ state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
95226	95164	break;
95227	95165	}
95228		- case 18446744073709546111LLU: // 99999998n9'''''''''''''''
	95166	+ case 18446744073709546117LLU: // 99999998oE'''''''''''''''
95229	95167	{
95230		- // variable u64 level_____ goes out of scope
95231		- // emitted destructur for type u64
95232		- (void)LOCAL_POP_MOVE(&heap, 40LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 40
95233		- state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
	95168	+ state.addr = 552437437528276992LLU == heap.data[*LOCAL_ACCESS(heap.data, 38LLU, 37LLU)].elem0 ? 18446744073709546115LLU : 18446744073709546114LLU;
95234	95169	break;
95235	95170	}
95236		- case 18446744073709546116LLU: // 99999998oD'''''''''''''''
	95171	+ case 18446744073709546115LLU: // 99999998oC'''''''''''''''
95237	95172	{
95238	95173	{
95239		- uint64_t arg = 0LLU;
95240		- tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 39LLU, 36LLU));
95241		- tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 39LLU, 32LLU));
95242		- tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 39LLU, 33LLU));
95243		- tree_push_move(&heap, 3LLU, &arg, &*LOCAL_ACCESS(heap.data, 39LLU, 34LLU));
95244		- tree_push_move(&heap, 4LLU, &arg, &*LOCAL_ACCESS(heap.data, 39LLU, 37LLU));
95245		-;
95246		- LOCAL_PUSH_MOVE(&heap, 39, &(heap.data[0].elem1)/address of current closure/, &arg);
	95174	+ uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 38LLU, 37LLU)].elem1;
	95175	+ LOCAL_PUSH_MOVE(&heap, 38, &(heap.data[0].elem1)/address of current closure/, &arg);
95247	95176	}
95248		- /parid2____/*LOCAL_ACCESS(heap.data, 40LLU, 36LLU) = 0LLU;
95249		-
95250		- {
95251		- uint64_t arg = /par_______/*access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU), 4LLU));
95252		- LOCAL_PUSH_MOVE(&heap, 40, &(heap.data[0].elem1)/address of current closure/, &arg);
95253		- }
95254		- {
95255		- uint64_t mainresult = heap.data[0].elem0;
95256		- heap.data[0].elem0 = 0;
95257		- {
95258		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 32LLU);
95259		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95260		- }
95261		- {
95262		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 39LLU), 1LLU);
95263		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95264		- }
95265		- // 2LLU
95266		- uint64_t return_to = 18446744073709546107LLU;
95267		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95268		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95269		- heap.data[0].elem1 = heap.data[0].elem0;
95270		- heap.data[0].elem0 = mainresult;
95271		- }
95272		- state.addr = 367395560426147840LLU; // TYPECOPY__
	95177	+ // parameter consume___ linearity_ goes out of scope
	95178	+ (void)LOCAL_POP_MOVE(&heap, 39LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 39
	95179	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95180	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95181	+ state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
95273	95182	break;
95274	95183	}
95275		- case 18446744073709546107LLU: // 99999998n5'''''''''''''''
	95184	+ case 18446744073709546114LLU: // 99999998oB'''''''''''''''
95276	95185	{
95277		- state.addr = 18446744073709546108LLU; // 99999998n6'''''''''''''''
95278		- break;
95279		- }
95280		- case 18446744073709546108LLU: // 99999998n6'''''''''''''''
95281		- {
95282	95186	{
95283	95187	uint64_t mainresult = heap.data[0].elem0;
95284	95188	heap.data[0].elem0 = 0;
95285	95189	{
95286		- uint64_t arg = /varlist___/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 25LLU);
	95190	+ uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 38LLU, 2LLU);
95287	95191	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95288	95192	}
95289		- {
95290		- uint64_t arg = /parid2____/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 36LLU);
95291		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95292		- }
95293		- {
95294		- uint64_t arg = /paridx____/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 38LLU);
95295		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95296		- }
95297		- {
95298		- uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 40LLU);
95299		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95300		- }
95301		- {
95302		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 32LLU);
95303		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95304		- }
95305		- {
95306		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 39LLU), 2LLU);
95307		- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95308		- }
95309		- {
95310		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 39LLU), 3LLU);
95311		- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95312		- }
95313		- // 7LLU
95314		- uint64_t return_to = 18446744073709546105LLU;
	95193	+ // 1LLU
	95194	+ uint64_t return_to = 18446744073709546111LLU;
95315	95195	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95316		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95196	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95317	95197	heap.data[0].elem1 = heap.data[0].elem0;
95318	95198	heap.data[0].elem0 = mainresult;
95319	95199	}
95320		- state.addr = 788334682132335200LLU; // pushbyline
	95200	+ state.addr = 819847183515949359LLU; // reportinit
95321	95201	break;
95322	95202	}
95323		- case 18446744073709546105LLU: // 99999998n3'''''''''''''''
	95203	+ case 18446744073709546111LLU: // 99999998n9'''''''''''''''
95324	95204	{
95325		- state.addr = 18446744073709546106LLU; // 99999998n4'''''''''''''''
	95205	+ state.addr = 18446744073709546112LLU; // 99999998o_'''''''''''''''
95326	95206	break;
95327	95207	}
95328		- case 18446744073709546106LLU: // 99999998n4'''''''''''''''
	95208	+ case 18446744073709546112LLU: // 99999998o_'''''''''''''''
95329	95209	{
95330		- // variable u64 INDIRECT__ goes out of scope
95331		- // emitted destructur for type u64
95332		- (void)LOCAL_POP_MOVE(&heap, 41LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 41
95333		- state.addr = 18446744073709546109LLU; // 99999998n7'''''''''''''''
95334		- break;
95335		- }
95336		- case 18446744073709546109LLU: // 99999998n7'''''''''''''''
95337		- {
95338		- // variable pardef____ par_______ goes out of scope
95339		- // emitted destructur for type pardef____
	95210	+ fprintf(stderr, "%s", "can't match 0 with ");
95340	95211	{
95341	95212	uint64_t mainresult = heap.data[0].elem0;
95342	95213	heap.data[0].elem0 = 0;
95343	95214	{
95344		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU);
	95215	+ uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 38LLU, 37LLU);
95345	95216	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95346	95217	}
95347	95218	// 1LLU
95348		- uint64_t return_to = 18446744073709546104LLU;
	95219	+ uint64_t return_to = 18446744073709546109LLU;
95349	95220	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95350	95221	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95351	95222	heap.data[0].elem1 = heap.data[0].elem0;
95352	95223	heap.data[0].elem0 = mainresult;
95353	95224	}
95354		- state.addr = 782700512565790404LLU; // pardef__$D
	95225	+ state.addr = 819847183516715616LLU; // reportline
95355	95226	break;
95356	95227	}
95357		- case 18446744073709546104LLU: // 99999998n2'''''''''''''''
	95228	+ case 18446744073709546109LLU: // 99999998n7'''''''''''''''
95358	95229	{
95359		- (void)LOCAL_POP_MOVE(&heap, 40LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 40
95360		- // variable u64 paridx____ goes out of scope
95361		- // emitted destructur for type u64
95362		- (void)LOCAL_POP_MOVE(&heap, 39LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx____ at 39
95363		- state.addr = 18446744073709546117LLU; // 99999998oE'''''''''''''''
	95230	+ state.addr = 18446744073709546110LLU; // 99999998n8'''''''''''''''
95364	95231	break;
95365	95232	}
95366		- case 18446744073709546117LLU: // 99999998oE'''''''''''''''
	95233	+ case 18446744073709546110LLU: // 99999998n8'''''''''''''''
95367	95234	{
95368		- // variable u64 REFERENCE_ goes out of scope
95369		- // (uninitialized -> no destructor-call)
95370		- (void)LOCAL_POP_MOVE(&heap, 38LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference REFERENCE_ at 38
95371		- // variable u64 parid2____ goes out of scope
95372		- // emitted destructur for type u64
95373		- (void)LOCAL_POP_MOVE(&heap, 37LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parid2____ at 37
95374		- state.addr = 18446744073709546118LLU; // 99999998oF'''''''''''''''
	95235	+ fprintf(stderr, "%s", " ");
	95236	+ fprintf(stderr, "%llu", (unsigned long long)/parnr_____/*LOCAL_ACCESS(heap.data, 38LLU, 29LLU));
	95237	+ fprintf(stderr, "%s", " parameter");
	95238	+ {
	95239	+ fprintf(stderr, "%s\n", "");
	95240	+ exit(-1);
	95241	+ }
	95242	+ state.addr = 18446744073709546113LLU; // 99999998oA'''''''''''''''
95375	95243	break;
95376	95244	}
95377		- case 18446744073709546118LLU: // 99999998oF'''''''''''''''
	95245	+ case 18446744073709546113LLU: // 99999998oA'''''''''''''''
95378	95246	{
95379		- state.addr = 18446744073709546119LLU; // 99999998oG'''''''''''''''
	95247	+ state.addr = 18446744073709546116LLU; // 99999998oD'''''''''''''''
95380	95248	break;
95381	95249	}
95382		- case 18446744073709546119LLU: // 99999998oG'''''''''''''''
	95250	+ case 18446744073709546116LLU: // 99999998oD'''''''''''''''
95383	95251	{
95384		- // variable u64 val_______ goes out of scope
95385		- // emitted destructur for type u64
95386		- (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference val_______ at 36
95387		- // variable linear____ linearity_ goes out of scope
95388		- // (uninitialized -> no destructor-call)
95389		- (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 35
95390		- // variable u64 mutable___ goes out of scope
95391		- // (uninitialized -> no destructor-call)
95392		- (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 34
95393		- // variable type______ type______ goes out of scope
95394		- // emitted destructur for type type______
95395	95252	{
	95253	+ uint64_t arg = 0LLU;
	95254	+ LOCAL_PUSH_MOVE(&heap, 38, &(heap.data[0].elem1)/address of current closure/, &arg);
	95255	+ }
	95256	+ /val_______/LOCAL_ACCESS(heap.data, 39LLU, 38LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 39LLU, 4LLU)));
	95257	+ {
	95258	+ uint64_t arg = 1LLU;
	95259	+ LOCAL_PUSH_MOVE(&heap, 39, &(heap.data[0].elem1)/address of current closure/, &arg);
	95260	+ }
	95261	+ {
95396	95262	uint64_t mainresult = heap.data[0].elem0;
95397	95263	heap.data[0].elem0 = 0;
95398	95264	{
95399		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 33LLU, 32LLU);
	95265	+ uint64_t arg = /level_____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU);
95400	95266	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95401	95267	}
95402	95268	// 1LLU
95403		- uint64_t return_to = 18446744073709546103LLU;
	95269	+ uint64_t return_to = 18446744073709546106LLU;
95404	95270	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95405	95271	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95406	95272	heap.data[0].elem1 = heap.data[0].elem0;
95407	95273	heap.data[0].elem0 = mainresult;
95408	95274	}
95409		- state.addr = 861504743757842116LLU; // type____$D
	95275	+ state.addr = 660197403663532032LLU; // indent____
95410	95276	break;
95411	95277	}
95412		- case 18446744073709546103LLU: // 99999998n1'''''''''''''''
	95278	+ case 18446744073709546106LLU: // 99999998n4'''''''''''''''
95413	95279	{
95414		- (void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 33
95415		- heap.availilable_size_for_dynamic_objects += 0LLU;
95416		- heap.availilable_size_for_dynamic_objects += 0LLU;
95417		- state.addr = 18446744073709546102LLU; // 99999998n0'''''''''''''''
	95280	+ state.addr = 18446744073709546107LLU; // 99999998n5'''''''''''''''
95418	95281	break;
95419	95282	}
95420		- case 18446744073709546136LLU: // 99999998oX'''''''''''''''
	95283	+ case 18446744073709546107LLU: // 99999998n5'''''''''''''''
95421	95284	{
	95285	+ fprintf(stdout, "%s", " if(");
95422	95286	{
95423		- uint64_t arg = 0LLU;
95424		- LOCAL_PUSH_MOVE(&heap, 32, &(heap.data[0].elem1)/address of current closure/, &arg);
95425		- }
95426		- /parid_____/LOCAL_ACCESS(heap.data, 33LLU, 32LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 33LLU, 4LLU)));
95427		- {
95428		- uint64_t arg = 0LLU;
95429		- uint64_t constrid = 861504796319285248LLU; // typeu64___
95430		- arg = pair_move(&heap, &constrid, &arg);
95431		-;
95432		- LOCAL_PUSH_MOVE(&heap, 33, &(heap.data[0].elem1)/address of current closure/, &arg);
95433		- }
95434		- {
95435	95287	uint64_t mainresult = heap.data[0].elem0;
95436	95288	heap.data[0].elem0 = 0;
95437	95289	{
95438		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 34LLU, 33LLU);
	95290	+ uint64_t arg = /defargcnt_/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 20LLU);
95439	95291	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95440	95292	}
95441	95293	{
95442		- uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 34LLU, 31LLU), 2LLU);
	95294	+ uint64_t arg = /defbodysz_/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 21LLU);
95443	95295	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95444	95296	}
95445		- // 2LLU
95446		- uint64_t return_to = 18446744073709546100LLU;
	95297	+ {
	95298	+ uint64_t arg = /remainsize/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 22LLU);
	95299	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95300	+ }
	95301	+ {
	95302	+ uint64_t arg = /paridx____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 33LLU);
	95303	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	95304	+ }
	95305	+ // 4LLU
	95306	+ uint64_t return_to = 18446744073709546104LLU;
95447	95307	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95448		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95308	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95449	95309	heap.data[0].elem1 = heap.data[0].elem0;
95450	95310	heap.data[0].elem0 = mainresult;
95451	95311	}
95452		- state.addr = 861504776686223360LLU; // typecopy__
	95312	+ state.addr = 587881359725559808LLU; // emitref___
95453	95313	break;
95454	95314	}
95455		- case 18446744073709546100LLU: // 99999998ny'''''''''''''''
	95315	+ case 18446744073709546104LLU: // 99999998n2'''''''''''''''
95456	95316	{
95457		- state.addr = 18446744073709546101LLU; // 99999998nz'''''''''''''''
	95317	+ state.addr = 18446744073709546105LLU; // 99999998n3'''''''''''''''
95458	95318	break;
95459	95319	}
95460		- case 18446744073709546101LLU: // 99999998nz'''''''''''''''
	95320	+ case 18446744073709546105LLU: // 99999998n3'''''''''''''''
95461	95321	{
	95322	+ fprintf(stdout, "%s", " != ");
	95323	+ fprintf(stdout, "%llu", (unsigned long long)/val_______/*LOCAL_ACCESS(heap.data, 40LLU, 38LLU));
	95324	+ fprintf(stdout, "%s", ")");
95462	95325	{
95463		- uint64_t arg = /sign______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 34LLU, 31LLU), 1LLU));
95464		- LOCAL_PUSH_MOVE(&heap, 34, &(heap.data[0].elem1)/address of current closure/, &arg);
95465		- }
95466		- {
95467		- uint64_t arg = 0LLU;
95468		- uint64_t constrid = 728618437845356544LLU; // maintain__
95469		- arg = pair_move(&heap, &constrid, &arg);
95470		-;
95471		- LOCAL_PUSH_MOVE(&heap, 35, &(heap.data[0].elem1)/address of current closure/, &arg);
95472		- }
95473		- {
95474	95326	uint64_t mainresult = heap.data[0].elem0;
95475	95327	heap.data[0].elem0 = 0;
95476	95328	{
95477		- uint64_t arg = /linearity_/LOCAL_ACCESS_ADDR(heap.data, 36LLU, 35LLU);
	95329	+ uint64_t arg = /level_____/LOCAL_ACCESS_ADDR(heap.data, 40LLU, 39LLU);
95478	95330	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95479	95331	}
95480	95332	{
95481		- uint64_t arg = /sign______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 36LLU, 31LLU), 0LLU);
	95333	+ uint64_t arg = /caseaddr__/*LOCAL_ACCESS(heap.data, 40LLU, 6LLU);
95482	95334	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95483	95335	}
95484	95336	// 2LLU
95485		- uint64_t return_to = 18446744073709546098LLU;
	95337	+ uint64_t return_to = 18446744073709546102LLU;
95486	95338	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95487	95339	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95488	95340	heap.data[0].elem1 = heap.data[0].elem0;
95489	95341	heap.data[0].elem0 = mainresult;
95490	95342	}
95491		- state.addr = 552446636209866541LLU; // copylinear
	95343	+ state.addr = 587881351406075392LLU; // emitjump2_
95492	95344	break;
95493	95345	}
95494		- case 18446744073709546098LLU: // 99999998nw'''''''''''''''
	95346	+ case 18446744073709546102LLU: // 99999998n0'''''''''''''''
95495	95347	{
95496		- state.addr = 18446744073709546099LLU; // 99999998nx'''''''''''''''
	95348	+ state.addr = 18446744073709546103LLU; // 99999998n1'''''''''''''''
95497	95349	break;
95498	95350	}
95499		- case 18446744073709546099LLU: // 99999998nx'''''''''''''''
	95351	+ case 18446744073709546103LLU: // 99999998n1'''''''''''''''
95500	95352	{
95501		- {
95502		- uint64_t arg = /parid_____/*LOCAL_ACCESS(heap.data, 36LLU, 32LLU);
95503		- LOCAL_PUSH_MOVE(&heap, 36, &(heap.data[0].elem1)/address of current closure/, &arg);
95504		- }
95505		- {
95506		- uint64_t arg = 1LLU;
95507		- LOCAL_PUSH_MOVE(&heap, 37, &(heap.data[0].elem1)/address of current closure/, &arg);
95508		- }
95509		- {
95510		- uint64_t arg = 0LLU;
95511		- tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 38LLU, 36LLU));
95512		- tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 38LLU, 33LLU));
95513		- tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 38LLU, 34LLU));
95514		- tree_push_move(&heap, 3LLU, &arg, &*LOCAL_ACCESS(heap.data, 38LLU, 35LLU));
95515		- tree_push_move(&heap, 4LLU, &arg, &*LOCAL_ACCESS(heap.data, 38LLU, 37LLU));
95516		-;
95517		- LOCAL_PUSH_MOVE(&heap, 38, &(heap.data[0].elem1)/address of current closure/, &arg);
95518		- }
95519		- {
95520		- uint64_t arg = /parnr_____/*LOCAL_ACCESS(heap.data, 39LLU, 29LLU);
95521		- LOCAL_PUSH_MOVE(&heap, 39, &(heap.data[0].elem1)/address of current closure/, &arg);
95522		- }
95523		- /paridx____/LOCAL_ACCESS(heap.data, 40LLU, 39LLU) = /paridx____/LOCAL_ACCESS(heap.data, 40LLU, 39LLU) + /returnbase/*LOCAL_ACCESS(heap.data, 40LLU, 26LLU);
95524		- {
95525		- uint64_t arg = /par_______/*access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 40LLU, 38LLU), 4LLU));
95526		- LOCAL_PUSH_MOVE(&heap, 40, &(heap.data[0].elem1)/address of current closure/, &arg);
95527		- }
95528		- {
95529		- uint64_t mainresult = heap.data[0].elem0;
95530		- heap.data[0].elem0 = 0;
95531		- {
95532		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 33LLU);
95533		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95534		- }
95535		- {
95536		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 38LLU), 1LLU);
95537		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95538		- }
95539		- // 2LLU
95540		- uint64_t return_to = 18446744073709546093LLU;
95541		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95542		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95543		- heap.data[0].elem1 = heap.data[0].elem0;
95544		- heap.data[0].elem0 = mainresult;
95545		- }
95546		- state.addr = 367395560426147840LLU; // TYPECOPY__
	95353	+ // variable u64 level_____ goes out of scope
	95354	+ // emitted destructur for type u64
	95355	+ (void)LOCAL_POP_MOVE(&heap, 40LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 40
	95356	+ state.addr = 18446744073709546108LLU; // 99999998n6'''''''''''''''
95547	95357	break;
95548	95358	}
95549		- case 18446744073709546093LLU: // 99999998nr'''''''''''''''
	95359	+ case 18446744073709546108LLU: // 99999998n6'''''''''''''''
95550	95360	{
95551		- state.addr = 18446744073709546094LLU; // 99999998ns'''''''''''''''
	95361	+ // variable u64 val_______ goes out of scope
	95362	+ // emitted destructur for type u64
	95363	+ (void)LOCAL_POP_MOVE(&heap, 39LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference val_______ at 39
	95364	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95365	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	95366	+ state.addr = 18446744073709546101LLU; // 99999998nz'''''''''''''''
95552	95367	break;
95553	95368	}
95554		- case 18446744073709546094LLU: // 99999998ns'''''''''''''''
	95369	+ case 18446744073709546121LLU: // 99999998oI'''''''''''''''
95555	95370	{
95556	95371	{
95557	95372	uint64_t mainresult = heap.data[0].elem0;
95558	95373	heap.data[0].elem0 = 0;
95559	95374	{
95560		- uint64_t arg = /varlist___/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 25LLU);
	95375	+ uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 38LLU, 2LLU);
95561	95376	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95562	95377	}
95563		- {
95564		- uint64_t arg = /parid_____/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 32LLU);
95565		- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95566		- }
95567		- {
95568		- uint64_t arg = /paridx____/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 39LLU);
95569		- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95570		- }
95571		- {
95572		- uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 40LLU);
95573		- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95574		- }
95575		- {
95576		- uint64_t arg = /type______/LOCAL_ACCESS_ADDR(heap.data, 41LLU, 33LLU);
95577		- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95578		- }
95579		- {
95580		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 38LLU), 2LLU);
95581		- LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95582		- }
95583		- {
95584		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS_ADDR(heap.data, 41LLU, 38LLU), 3LLU);
95585		- LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95586		- }
95587		- // 7LLU
95588		- uint64_t return_to = 18446744073709546091LLU;
	95378	+ // 1LLU
	95379	+ uint64_t return_to = 18446744073709546099LLU;
95589	95380	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95590		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	95381	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95591	95382	heap.data[0].elem1 = heap.data[0].elem0;
95592	95383	heap.data[0].elem0 = mainresult;
95593	95384	}
95594		- state.addr = 788334682132335200LLU; // pushbyline
	95385	+ state.addr = 819847183515949359LLU; // reportinit
95595	95386	break;
95596	95387	}
95597		- case 18446744073709546091LLU: // 99999998np'''''''''''''''
	95388	+ case 18446744073709546099LLU: // 99999998nx'''''''''''''''
95598	95389	{
95599		- state.addr = 18446744073709546092LLU; // 99999998nq'''''''''''''''
	95390	+ state.addr = 18446744073709546100LLU; // 99999998ny'''''''''''''''
95600	95391	break;
95601	95392	}
95602		- case 18446744073709546092LLU: // 99999998nq'''''''''''''''
	95393	+ case 18446744073709546100LLU: // 99999998ny'''''''''''''''
95603	95394	{
95604		- // variable u64 INDIRECT__ goes out of scope
95605		- // emitted destructur for type u64
95606		- (void)LOCAL_POP_MOVE(&heap, 41LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 41
95607		- state.addr = 18446744073709546095LLU; // 99999998nt'''''''''''''''
	95395	+ fprintf(stderr, "%s", "unexpected char ");
	95396	+ putc((char)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 38LLU, 4LLU)), stderr);
	95397	+ {
	95398	+ fprintf(stderr, "%s\n", "");
	95399	+ exit(-1);
	95400	+ }
	95401	+ state.addr = 18446744073709546101LLU; // 99999998nz'''''''''''''''
95608	95402	break;
95609	95403	}
95610		- case 18446744073709546095LLU: // 99999998nt'''''''''''''''
	95404	+ case 18446744073709546101LLU: // 99999998nz'''''''''''''''
95611	95405	{
95612		- // variable u64 paridx____ goes out of scope
95613		- // emitted destructur for type u64
95614		- (void)LOCAL_POP_MOVE(&heap, 40LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx____ at 40
95615		- state.addr = 18446744073709546096LLU; // 99999998nu'''''''''''''''
	95406	+ state.addr = 18446744073709546127LLU; // 99999998oO'''''''''''''''
95616	95407	break;
95617	95408	}
95618		- case 18446744073709546096LLU: // 99999998nu'''''''''''''''
	95409	+ case 18446744073709546127LLU: // 99999998oO'''''''''''''''
95619	95410	{
95620		- // variable pardef____ par_______ goes out of scope
95621		- // emitted destructur for type pardef____
	95411	+ /sym_______/*LOCAL_ACCESS(heap.data, 38LLU, 28LLU) = 44LLU;
	95412	+
	95413	+ ++/parnr_____/*LOCAL_ACCESS(heap.data, 38LLU, 29LLU);
	95414	+ // variable linear____ linearity_ goes out of scope
	95415	+ // emitted destructur for type linear____
95622	95416	{
95623	95417	uint64_t mainresult = heap.data[0].elem0;
95624	95418	heap.data[0].elem0 = 0;
95625	95419	{
95626		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 39LLU, 38LLU);
	95420	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 38LLU, 37LLU);
95627	95421	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95628	95422	}
95629	95423	// 1LLU
95630		- uint64_t return_to = 18446744073709546090LLU;
	95424	+ uint64_t return_to = 18446744073709546098LLU;
95631	95425	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95632	95426	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95633	95427	heap.data[0].elem1 = heap.data[0].elem0;
95634	95428	heap.data[0].elem0 = mainresult;
95635	95429	}
95636		- state.addr = 782700512565790404LLU; // pardef__$D
	95430	+ state.addr = 712877190781339332LLU; // linear__$D
95637	95431	break;
95638	95432	}
95639		- case 18446744073709546090LLU: // 99999998no'''''''''''''''
	95433	+ case 18446744073709546098LLU: // 99999998nw'''''''''''''''
95640	95434	{
95641		- (void)LOCAL_POP_MOVE(&heap, 39LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 39
95642		- // variable u64 REFERENCE_ goes out of scope
95643		- // (uninitialized -> no destructor-call)
95644		- (void)LOCAL_POP_MOVE(&heap, 38LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference REFERENCE_ at 38
95645		- // variable u64 parid2____ goes out of scope
95646		- // (uninitialized -> no destructor-call)
95647		- (void)LOCAL_POP_MOVE(&heap, 37LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parid2____ at 37
95648		- state.addr = 18446744073709546097LLU; // 99999998nv'''''''''''''''
95649		- break;
95650		- }
95651		- case 18446744073709546097LLU: // 99999998nv'''''''''''''''
95652		- {
95653		- // variable linear____ linearity_ goes out of scope
95654		- // (uninitialized -> no destructor-call)
95655		- (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 36
	95435	+ (void)LOCAL_POP_MOVE(&heap, 38LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 38
95656	95436	// variable u64 mutable___ goes out of scope
95657		- // (uninitialized -> no destructor-call)
95658		- (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 35
	95437	+ // emitted destructur for type u64
	95438	+ (void)LOCAL_POP_MOVE(&heap, 37LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 37
95659	95439	// variable type______ type______ goes out of scope
95660	95440	// emitted destructur for type type______
95661	95441	{

		@@ -95662,11 +95442,11 @@
95662	95442	uint64_t mainresult = heap.data[0].elem0;
95663	95443	heap.data[0].elem0 = 0;
95664	95444	{
95665		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 34LLU, 33LLU);
	95445	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 36LLU, 35LLU);
95666	95446	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95667	95447	}
95668	95448	// 1LLU
95669		- uint64_t return_to = 18446744073709546089LLU;
	95449	+ uint64_t return_to = 18446744073709546097LLU;
95670	95450	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95671	95451	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95672	95452	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95675,20 +95455,18 @@
95675	95455	state.addr = 861504743757842116LLU; // type____$D
95676	95456	break;
95677	95457	}
95678		- case 18446744073709546089LLU: // 99999998nn'''''''''''''''
	95458	+ case 18446744073709546097LLU: // 99999998nv'''''''''''''''
95679	95459	{
95680		- (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 34
	95460	+ (void)LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 36
	95461	+ // variable u64 REFERENCE_ goes out of scope
	95462	+ // emitted destructur for type u64
	95463	+ (void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference REFERENCE_ at 35
	95464	+ // variable u64 paridx____ goes out of scope
	95465	+ // emitted destructur for type u64
	95466	+ (void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx____ at 34
95681	95467	// variable u64 parid_____ goes out of scope
95682	95468	// emitted destructur for type u64
95683	95469	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parid_____ at 33
95684		- state.addr = 18446744073709546102LLU; // 99999998n0'''''''''''''''
95685		- break;
95686		- }
95687		- case 18446744073709546102LLU: // 99999998n0'''''''''''''''
95688		- {
95689		- /sym_______/*LOCAL_ACCESS(heap.data, 32LLU, 28LLU) = 44LLU;
95690		-
95691		- ++/parnr_____/*LOCAL_ACCESS(heap.data, 32LLU, 29LLU);
95692	95470	// parameter-reference signdef___ sign______ goes out of scope
95693	95471	// parameter-reference list<signdef___> signs_____ goes out of scope
95694	95472	state.addr = 18446744073709546152LLU; // 99999998om'''''''''''''''

		@@ -95705,10 +95483,10 @@
95705	95483	// variable u64 argscount_ goes out of scope
95706	95484	// emitted destructur for type u64
95707	95485	(void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference argscount_ at 31
95708		- state.addr = 18446744073709546088LLU; // 99999998nm'''''''''''''''
	95486	+ state.addr = 18446744073709546096LLU; // 99999998nu'''''''''''''''
95709	95487	break;
95710	95488	}
95711		- case 18446744073709546088LLU: // 99999998nm'''''''''''''''
	95489	+ case 18446744073709546096LLU: // 99999998nu'''''''''''''''
95712	95490	{
95713	95491	{
95714	95492	uint64_t mainresult = heap.data[0].elem0;

		@@ -95718,7 +95496,7 @@
95718	95496	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95719	95497	}
95720	95498	// 1LLU
95721		- uint64_t return_to = 18446744073709546086LLU;
	95499	+ uint64_t return_to = 18446744073709546094LLU;
95722	95500	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95723	95501	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95724	95502	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95727,12 +95505,12 @@
95727	95505	state.addr = 839519719621918720LLU; // skipws____
95728	95506	break;
95729	95507	}
95730		- case 18446744073709546086LLU: // 99999998nk'''''''''''''''
	95508	+ case 18446744073709546094LLU: // 99999998ns'''''''''''''''
95731	95509	{
95732		- state.addr = 18446744073709546087LLU; // 99999998nl'''''''''''''''
	95510	+ state.addr = 18446744073709546095LLU; // 99999998nt'''''''''''''''
95733	95511	break;
95734	95512	}
95735		- case 18446744073709546087LLU: // 99999998nl'''''''''''''''
	95513	+ case 18446744073709546095LLU: // 99999998nt'''''''''''''''
95736	95514	{
95737	95515	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 30LLU, 4LLU)));
95738	95516	{

		@@ -95743,7 +95521,7 @@
95743	95521	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95744	95522	}
95745	95523	// 1LLU
95746		- uint64_t return_to = 18446744073709546084LLU;
	95524	+ uint64_t return_to = 18446744073709546092LLU;
95747	95525	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95748	95526	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95749	95527	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95752,12 +95530,12 @@
95752	95530	state.addr = 839519719621918720LLU; // skipws____
95753	95531	break;
95754	95532	}
95755		- case 18446744073709546084LLU: // 99999998ni'''''''''''''''
	95533	+ case 18446744073709546092LLU: // 99999998nq'''''''''''''''
95756	95534	{
95757		- state.addr = 18446744073709546085LLU; // 99999998nj'''''''''''''''
	95535	+ state.addr = 18446744073709546093LLU; // 99999998nr'''''''''''''''
95758	95536	break;
95759	95537	}
95760		- case 18446744073709546085LLU: // 99999998nj'''''''''''''''
	95538	+ case 18446744073709546093LLU: // 99999998nr'''''''''''''''
95761	95539	{
95762	95540	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 30LLU, 4LLU)), stdin);
95763	95541	if('{' != (char)getchar())

		@@ -95765,15 +95543,15 @@
95765	95543	fprintf(stderr, "match failed at char %c\n", (char)123LLU);
95766	95544	exit(-1);
95767	95545	}
95768		- state.addr = 18446744073709546083LLU; // 99999998nh'''''''''''''''
	95546	+ state.addr = 18446744073709546091LLU; // 99999998np'''''''''''''''
95769	95547	break;
95770	95548	}
95771		- case 18446744073709546083LLU: // 99999998nh'''''''''''''''
	95549	+ case 18446744073709546091LLU: // 99999998np'''''''''''''''
95772	95550	{
95773	95551	access_heap(heap.data, LOCAL_ACCESS(heap.data, 30LLU, 4LLU)) = (uint64_t)getchar();
95774	95552	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 30LLU, 4LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 30LLU, 4LLU)) > 255)
95775	95553	{
95776		- state.addr = 18446744073709546082LLU; // 99999998ng'''''''''''''''
	95554	+ state.addr = 18446744073709546090LLU; // 99999998no'''''''''''''''
95777	95555	break;
95778	95556	}
95779	95557	{

		@@ -95844,7 +95622,7 @@
95844	95622	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95845	95623	}
95846	95624	// 16LLU
95847		- uint64_t return_to = 18446744073709546080LLU;
	95625	+ uint64_t return_to = 18446744073709546088LLU;
95848	95626	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95849	95627	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95850	95628	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95853,31 +95631,31 @@
95853	95631	state.addr = 782701543301228454LLU; // parseblock
95854	95632	break;
95855	95633	}
95856		- case 18446744073709546080LLU: // 99999998ne'''''''''''''''
	95634	+ case 18446744073709546088LLU: // 99999998nm'''''''''''''''
95857	95635	{
95858		- state.addr = 18446744073709546081LLU; // 99999998nf'''''''''''''''
	95636	+ state.addr = 18446744073709546089LLU; // 99999998nn'''''''''''''''
95859	95637	break;
95860	95638	}
95861		- case 18446744073709546081LLU: // 99999998nf'''''''''''''''
	95639	+ case 18446744073709546089LLU: // 99999998nn'''''''''''''''
95862	95640	{
95863		- state.addr = 18446744073709546083LLU; // 99999998nh'''''''''''''''
	95641	+ state.addr = 18446744073709546091LLU; // 99999998np'''''''''''''''
95864	95642	break;
95865	95643	}
95866		- case 18446744073709546082LLU: // 99999998ng'''''''''''''''
	95644	+ case 18446744073709546090LLU: // 99999998no'''''''''''''''
95867	95645	{
95868		- state.addr = /varlist___/*LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709546079LLU : 18446744073709546078LLU;
	95646	+ state.addr = /varlist___/*LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709546087LLU : 18446744073709546086LLU;
95869	95647	break;
95870	95648	}
95871		- case 18446744073709546079LLU: // 99999998nd'''''''''''''''
	95649	+ case 18446744073709546087LLU: // 99999998nl'''''''''''''''
95872	95650	{
95873	95651	{
95874	95652	fprintf(stderr, "%s\n", "INTERNAL ERROR: varlist not empty at end of definition\n");
95875	95653	exit(-1);
95876	95654	}
95877		- state.addr = 18446744073709546078LLU; // 99999998nc'''''''''''''''
	95655	+ state.addr = 18446744073709546086LLU; // 99999998nk'''''''''''''''
95878	95656	break;
95879	95657	}
95880		- case 18446744073709546078LLU: // 99999998nc'''''''''''''''
	95658	+ case 18446744073709546086LLU: // 99999998nk'''''''''''''''
95881	95659	{
95882	95660	{
95883	95661	uint64_t arg = /results___/*LOCAL_ACCESS(heap.data, 30LLU, 19LLU);

		@@ -95887,10 +95665,10 @@
95887	95665	uint64_t arg = 0;
95888	95666	LOCAL_PUSH_MOVE(&heap, 31, &(heap.data[0].elem1)/address of current closure/, &arg);
95889	95667	}
95890		- state.addr = 18446744073709546077LLU; // 99999998nb'''''''''''''''
	95668	+ state.addr = 18446744073709546085LLU; // 99999998nj'''''''''''''''
95891	95669	break;
95892	95670	}
95893		- case 18446744073709546077LLU: // 99999998nb'''''''''''''''
	95671	+ case 18446744073709546085LLU: // 99999998nj'''''''''''''''
95894	95672	{
95895	95673	if(!*LOCAL_ACCESS(heap.data, 32LLU, 30LLU))
95896	95674	{

		@@ -95897,7 +95675,7 @@
95897	95675	(void)LOCAL_POP_MOVE(&heap, 32LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 32
95898	95676	(void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 31
95899	95677	{
95900		- state.addr = 18446744073709546076LLU; // 99999998na'''''''''''''''
	95678	+ state.addr = 18446744073709546084LLU; // 99999998ni'''''''''''''''
95901	95679	break;
95902	95680	}
95903	95681	}

		@@ -95927,7 +95705,7 @@
95927	95705	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95928	95706	}
95929	95707	// 4LLU
95930		- uint64_t return_to = 18446744073709546074LLU;
	95708	+ uint64_t return_to = 18446744073709546082LLU;
95931	95709	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95932	95710	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95933	95711	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95936,12 +95714,12 @@
95936	95714	state.addr = 587881357748656161LLU; // emitpopref
95937	95715	break;
95938	95716	}
95939		- case 18446744073709546074LLU: // 99999998nZ'''''''''''''''
	95717	+ case 18446744073709546082LLU: // 99999998ng'''''''''''''''
95940	95718	{
95941		- state.addr = 18446744073709546075LLU; // 99999998n$'''''''''''''''
	95719	+ state.addr = 18446744073709546083LLU; // 99999998nh'''''''''''''''
95942	95720	break;
95943	95721	}
95944		- case 18446744073709546075LLU: // 99999998n$'''''''''''''''
	95722	+ case 18446744073709546083LLU: // 99999998nh'''''''''''''''
95945	95723	{
95946	95724	// variable u64 resultid__ goes out of scope
95947	95725	// emitted destructur for type u64

		@@ -95948,10 +95726,10 @@
95948	95726	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resultid__ at 33
95949	95727	// parameter-reference resdest___ respar____ goes out of scope
95950	95728	// parameter list<resdest___> results___ goes out of scope
95951		- state.addr = 18446744073709546077LLU; // 99999998nb'''''''''''''''
	95729	+ state.addr = 18446744073709546085LLU; // 99999998nj'''''''''''''''
95952	95730	break;
95953	95731	}
95954		- case 18446744073709546076LLU: // 99999998na'''''''''''''''
	95732	+ case 18446744073709546084LLU: // 99999998ni'''''''''''''''
95955	95733	{
95956	95734	{
95957	95735	uint64_t mainresult = heap.data[0].elem0;

		@@ -95969,7 +95747,7 @@
95969	95747	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
95970	95748	}
95971	95749	// 3LLU
95972		- uint64_t return_to = 18446744073709546072LLU;
	95750	+ uint64_t return_to = 18446744073709546080LLU;
95973	95751	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
95974	95752	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
95975	95753	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -95978,12 +95756,12 @@
95978	95756	state.addr = 587881353282000896LLU; // emitleave_
95979	95757	break;
95980	95758	}
95981		- case 18446744073709546072LLU: // 99999998nX'''''''''''''''
	95759	+ case 18446744073709546080LLU: // 99999998ne'''''''''''''''
95982	95760	{
95983		- state.addr = 18446744073709546073LLU; // 99999998nY'''''''''''''''
	95761	+ state.addr = 18446744073709546081LLU; // 99999998nf'''''''''''''''
95984	95762	break;
95985	95763	}
95986		- case 18446744073709546073LLU: // 99999998nY'''''''''''''''
	95764	+ case 18446744073709546081LLU: // 99999998nf'''''''''''''''
95987	95765	{
95988	95766	// variable u64 parnr_____ goes out of scope
95989	95767	// emitted destructur for type u64

		@@ -96009,14 +95787,14 @@
96009	95787	uint64_t arg = 0;
96010	95788	LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
96011	95789	}
96012		- state.addr = 18446744073709546070LLU; // 99999998nV'''''''''''''''
	95790	+ state.addr = 18446744073709546078LLU; // 99999998nc'''''''''''''''
96013	95791	break;
96014	95792	}
96015		- case 18446744073709546070LLU: // 99999998nV'''''''''''''''
	95793	+ case 18446744073709546078LLU: // 99999998nc'''''''''''''''
96016	95794	{
96017	95795	if(!LOCAL_ACCESS(heap.data, 27LLU, 25LLU)/list*/)
96018	95796	{
96019		- state.addr = 18446744073709546071LLU; // 99999998nW'''''''''''''''
	95797	+ state.addr = 18446744073709546079LLU; // 99999998nd'''''''''''''''
96020	95798	break;
96021	95799	}
96022	95800	LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 27LLU, 25LLU)/list/, 9);

		@@ -96028,7 +95806,7 @@
96028	95806	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96029	95807	}
96030	95808	// 1LLU
96031		- uint64_t return_to = 18446744073709546069LLU;
	95809	+ uint64_t return_to = 18446744073709546077LLU;
96032	95810	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96033	95811	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96034	95812	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96037,12 +95815,12 @@
96037	95815	state.addr = 890786982252725956LLU; // varentry$D
96038	95816	break;
96039	95817	}
96040		- case 18446744073709546069LLU: // 99999998nU'''''''''''''''
	95818	+ case 18446744073709546077LLU: // 99999998nb'''''''''''''''
96041	95819	{
96042		- state.addr = 18446744073709546070LLU; // 99999998nV'''''''''''''''
	95820	+ state.addr = 18446744073709546078LLU; // 99999998nc'''''''''''''''
96043	95821	break;
96044	95822	}
96045		- case 18446744073709546071LLU: // 99999998nW'''''''''''''''
	95823	+ case 18446744073709546079LLU: // 99999998nd'''''''''''''''
96046	95824	{
96047	95825	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
96048	95826	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varlist___ at 26

		@@ -96068,14 +95846,14 @@
96068	95846	uint64_t arg = 0;
96069	95847	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
96070	95848	}
96071		- state.addr = 18446744073709546067LLU; // 99999998nS'''''''''''''''
	95849	+ state.addr = 18446744073709546075LLU; // 99999998n$'''''''''''''''
96072	95850	break;
96073	95851	}
96074		- case 18446744073709546067LLU: // 99999998nS'''''''''''''''
	95852	+ case 18446744073709546075LLU: // 99999998n$'''''''''''''''
96075	95853	{
96076	95854	if(!LOCAL_ACCESS(heap.data, 21LLU, 19LLU)/list*/)
96077	95855	{
96078		- state.addr = 18446744073709546068LLU; // 99999998nT'''''''''''''''
	95856	+ state.addr = 18446744073709546076LLU; // 99999998na'''''''''''''''
96079	95857	break;
96080	95858	}
96081	95859	LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 21LLU, 19LLU)/list/, 4);

		@@ -96087,7 +95865,7 @@
96087	95865	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96088	95866	}
96089	95867	// 1LLU
96090		- uint64_t return_to = 18446744073709546066LLU;
	95868	+ uint64_t return_to = 18446744073709546074LLU;
96091	95869	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96092	95870	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96093	95871	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96096,12 +95874,12 @@
96096	95874	state.addr = 819859607768532676LLU; // resdest_$D
96097	95875	break;
96098	95876	}
96099		- case 18446744073709546066LLU: // 99999998nR'''''''''''''''
	95877	+ case 18446744073709546074LLU: // 99999998nZ'''''''''''''''
96100	95878	{
96101		- state.addr = 18446744073709546067LLU; // 99999998nS'''''''''''''''
	95879	+ state.addr = 18446744073709546075LLU; // 99999998n$'''''''''''''''
96102	95880	break;
96103	95881	}
96104		- case 18446744073709546068LLU: // 99999998nT'''''''''''''''
	95882	+ case 18446744073709546076LLU: // 99999998na'''''''''''''''
96105	95883	{
96106	95884	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
96107	95885	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 20

		@@ -96165,7 +95943,7 @@
96165	95943	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96166	95944	}
96167	95945	// 1LLU
96168		- uint64_t return_to = 18446744073709546064LLU;
	95946	+ uint64_t return_to = 18446744073709546072LLU;
96169	95947	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96170	95948	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96171	95949	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96174,12 +95952,12 @@
96174	95952	state.addr = 839519719621918720LLU; // skipws____
96175	95953	break;
96176	95954	}
96177		- case 18446744073709546064LLU: // 99999998nP'''''''''''''''
	95955	+ case 18446744073709546072LLU: // 99999998nX'''''''''''''''
96178	95956	{
96179		- state.addr = 18446744073709546065LLU; // 99999998nQ'''''''''''''''
	95957	+ state.addr = 18446744073709546073LLU; // 99999998nY'''''''''''''''
96180	95958	break;
96181	95959	}
96182		- case 18446744073709546065LLU: // 99999998nQ'''''''''''''''
	95960	+ case 18446744073709546073LLU: // 99999998nY'''''''''''''''
96183	95961	{
96184	95962	{
96185	95963	uint64_t mainresult = heap.data[0].elem0;

		@@ -96193,7 +95971,7 @@
96193	95971	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96194	95972	}
96195	95973	// 2LLU
96196		- uint64_t return_to = 18446744073709546062LLU;
	95974	+ uint64_t return_to = 18446744073709546070LLU;
96197	95975	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96198	95976	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96199	95977	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96202,17 +95980,17 @@
96202	95980	state.addr = 661649452408901632LLU; // isnoteof__
96203	95981	break;
96204	95982	}
96205		- case 18446744073709546062LLU: // 99999998nN'''''''''''''''
	95983	+ case 18446744073709546070LLU: // 99999998nV'''''''''''''''
96206	95984	{
96207		- state.addr = 18446744073709546063LLU; // 99999998nO'''''''''''''''
	95985	+ state.addr = 18446744073709546071LLU; // 99999998nW'''''''''''''''
96208	95986	break;
96209	95987	}
96210		- case 18446744073709546063LLU: // 99999998nO'''''''''''''''
	95988	+ case 18446744073709546071LLU: // 99999998nW'''''''''''''''
96211	95989	{
96212		- state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709546061LLU : 18446744073709546060LLU;
	95990	+ state.addr = /buf_______/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709546069LLU : 18446744073709546068LLU;
96213	95991	break;
96214	95992	}
96215		- case 18446744073709546061LLU: // 99999998nM'''''''''''''''
	95993	+ case 18446744073709546069LLU: // 99999998nU'''''''''''''''
96216	95994	{
96217	95995	{
96218	95996	uint64_t arg = 0LLU;

		@@ -96224,10 +96002,10 @@
96224	96002	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
96225	96003	}
96226	96004	/isstruct__/LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /isstruct__/LOCAL_ACCESS(heap.data, 9LLU, 8LLU) == /id________/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
96227		- state.addr = /isstruct__/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709546059LLU : 18446744073709546058LLU;
	96005	+ state.addr = /isstruct__/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709546067LLU : 18446744073709546066LLU;
96228	96006	break;
96229	96007	}
96230		- case 18446744073709546059LLU: // 99999998nK'''''''''''''''
	96008	+ case 18446744073709546067LLU: // 99999998nS'''''''''''''''
96231	96009	{
96232	96010	{
96233	96011	uint64_t mainresult = heap.data[0].elem0;

		@@ -96237,7 +96015,7 @@
96237	96015	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96238	96016	}
96239	96017	// 1LLU
96240		- uint64_t return_to = 18446744073709546056LLU;
	96018	+ uint64_t return_to = 18446744073709546064LLU;
96241	96019	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96242	96020	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96243	96021	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96246,12 +96024,12 @@
96246	96024	state.addr = 839519719621918720LLU; // skipws____
96247	96025	break;
96248	96026	}
96249		- case 18446744073709546056LLU: // 99999998nH'''''''''''''''
	96027	+ case 18446744073709546064LLU: // 99999998nP'''''''''''''''
96250	96028	{
96251		- state.addr = 18446744073709546057LLU; // 99999998nI'''''''''''''''
	96029	+ state.addr = 18446744073709546065LLU; // 99999998nQ'''''''''''''''
96252	96030	break;
96253	96031	}
96254		- case 18446744073709546057LLU: // 99999998nI'''''''''''''''
	96032	+ case 18446744073709546065LLU: // 99999998nQ'''''''''''''''
96255	96033	{
96256	96034	/id________/LOCAL_ACCESS(heap.data, 9LLU, 7LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU)));
96257	96035	{

		@@ -96274,7 +96052,7 @@
96274	96052	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96275	96053	}
96276	96054	// 3LLU
96277		- uint64_t return_to = 18446744073709546053LLU;
	96055	+ uint64_t return_to = 18446744073709546061LLU;
96278	96056	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96279	96057	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96280	96058	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96283,17 +96061,17 @@
96283	96061	state.addr = 590977518136150752LLU; // existstype
96284	96062	break;
96285	96063	}
96286		- case 18446744073709546053LLU: // 99999998nE'''''''''''''''
	96064	+ case 18446744073709546061LLU: // 99999998nM'''''''''''''''
96287	96065	{
96288		- state.addr = 18446744073709546054LLU; // 99999998nF'''''''''''''''
	96066	+ state.addr = 18446744073709546062LLU; // 99999998nN'''''''''''''''
96289	96067	break;
96290	96068	}
96291		- case 18446744073709546054LLU: // 99999998nF'''''''''''''''
	96069	+ case 18446744073709546062LLU: // 99999998nN'''''''''''''''
96292	96070	{
96293		- state.addr = /exists____/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709546052LLU : 18446744073709546051LLU;
	96071	+ state.addr = /exists____/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709546060LLU : 18446744073709546059LLU;
96294	96072	break;
96295	96073	}
96296		- case 18446744073709546052LLU: // 99999998nD'''''''''''''''
	96074	+ case 18446744073709546060LLU: // 99999998nL'''''''''''''''
96297	96075	{
96298	96076	fprintf(stderr, "%s", "re-definition of struct ");
96299	96077	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU));

		@@ -96301,18 +96079,18 @@
96301	96079	fprintf(stderr, "%s\n", "");
96302	96080	exit(-1);
96303	96081	}
96304		- state.addr = 18446744073709546051LLU; // 99999998nC'''''''''''''''
	96082	+ state.addr = 18446744073709546059LLU; // 99999998nK'''''''''''''''
96305	96083	break;
96306	96084	}
96307		- case 18446744073709546051LLU: // 99999998nC'''''''''''''''
	96085	+ case 18446744073709546059LLU: // 99999998nK'''''''''''''''
96308	96086	{
96309	96087	// variable u64 exists____ goes out of scope
96310	96088	// emitted destructur for type u64
96311	96089	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference exists____ at 10
96312		- state.addr = 18446744073709546055LLU; // 99999998nG'''''''''''''''
	96090	+ state.addr = 18446744073709546063LLU; // 99999998nO'''''''''''''''
96313	96091	break;
96314	96092	}
96315		- case 18446744073709546055LLU: // 99999998nG'''''''''''''''
	96093	+ case 18446744073709546063LLU: // 99999998nO'''''''''''''''
96316	96094	{
96317	96095	{
96318	96096	uint64_t arg = 0LLU;

		@@ -96338,7 +96116,7 @@
96338	96116	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96339	96117	}
96340	96118	// 4LLU
96341		- uint64_t return_to = 18446744073709546049LLU;
	96119	+ uint64_t return_to = 18446744073709546057LLU;
96342	96120	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96343	96121	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96344	96122	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96347,12 +96125,12 @@
96347	96125	state.addr = 782701543351519790LLU; // parseelems
96348	96126	break;
96349	96127	}
96350		- case 18446744073709546049LLU: // 99999998nA'''''''''''''''
	96128	+ case 18446744073709546057LLU: // 99999998nI'''''''''''''''
96351	96129	{
96352		- state.addr = 18446744073709546050LLU; // 99999998nB'''''''''''''''
	96130	+ state.addr = 18446744073709546058LLU; // 99999998nJ'''''''''''''''
96353	96131	break;
96354	96132	}
96355		- case 18446744073709546050LLU: // 99999998nB'''''''''''''''
	96133	+ case 18446744073709546058LLU: // 99999998nJ'''''''''''''''
96356	96134	{
96357	96135	{
96358	96136	uint64_t mainresult = heap.data[0].elem0;

		@@ -96362,7 +96140,7 @@
96362	96140	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96363	96141	}
96364	96142	// 1LLU
96365		- uint64_t return_to = 18446744073709546047LLU;
	96143	+ uint64_t return_to = 18446744073709546055LLU;
96366	96144	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96367	96145	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96368	96146	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96371,12 +96149,12 @@
96371	96149	state.addr = 839519719621918720LLU; // skipws____
96372	96150	break;
96373	96151	}
96374		- case 18446744073709546047LLU: // 99999998m9'''''''''''''''
	96152	+ case 18446744073709546055LLU: // 99999998nG'''''''''''''''
96375	96153	{
96376		- state.addr = 18446744073709546048LLU; // 99999998n_'''''''''''''''
	96154	+ state.addr = 18446744073709546056LLU; // 99999998nH'''''''''''''''
96377	96155	break;
96378	96156	}
96379		- case 18446744073709546048LLU: // 99999998n_'''''''''''''''
	96157	+ case 18446744073709546056LLU: // 99999998nH'''''''''''''''
96380	96158	{
96381	96159	{
96382	96160	uint64_t arg = 0LLU;

		@@ -96403,7 +96181,7 @@
96403	96181	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96404	96182	}
96405	96183	// 2LLU
96406		- uint64_t return_to = 18446744073709546044LLU;
	96184	+ uint64_t return_to = 18446744073709546052LLU;
96407	96185	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96408	96186	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96409	96187	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96412,12 +96190,12 @@
96412	96190	state.addr = 621679233931860255LLU; // gendestrid
96413	96191	break;
96414	96192	}
96415		- case 18446744073709546044LLU: // 99999998m6'''''''''''''''
	96193	+ case 18446744073709546052LLU: // 99999998nD'''''''''''''''
96416	96194	{
96417		- state.addr = 18446744073709546045LLU; // 99999998m7'''''''''''''''
	96195	+ state.addr = 18446744073709546053LLU; // 99999998nE'''''''''''''''
96418	96196	break;
96419	96197	}
96420		- case 18446744073709546045LLU: // 99999998m7'''''''''''''''
	96198	+ case 18446744073709546053LLU: // 99999998nE'''''''''''''''
96421	96199	{
96422	96200	{
96423	96201	uint64_t mainresult = heap.data[0].elem0;

		@@ -96427,7 +96205,7 @@
96427	96205	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96428	96206	}
96429	96207	// 1LLU
96430		- uint64_t return_to = 18446744073709546042LLU;
	96208	+ uint64_t return_to = 18446744073709546050LLU;
96431	96209	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96432	96210	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96433	96211	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96436,12 +96214,12 @@
96436	96214	state.addr = 587881345921715008LLU; // emitenter_
96437	96215	break;
96438	96216	}
96439		- case 18446744073709546042LLU: // 99999998m4'''''''''''''''
	96217	+ case 18446744073709546050LLU: // 99999998nB'''''''''''''''
96440	96218	{
96441		- state.addr = 18446744073709546043LLU; // 99999998m5'''''''''''''''
	96219	+ state.addr = 18446744073709546051LLU; // 99999998nC'''''''''''''''
96442	96220	break;
96443	96221	}
96444		- case 18446744073709546043LLU: // 99999998m5'''''''''''''''
	96222	+ case 18446744073709546051LLU: // 99999998nC'''''''''''''''
96445	96223	{
96446	96224	{
96447	96225	uint64_t arg = 1LLU;

		@@ -96455,7 +96233,7 @@
96455	96233	uint64_t mainresult = heap.data[0].elem0;
96456	96234	heap.data[0].elem0 = 0;
96457	96235	// 0LLU
96458		- uint64_t return_to = 18446744073709546040LLU;
	96236	+ uint64_t return_to = 18446744073709546048LLU;
96459	96237	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96460	96238	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96461	96239	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96464,12 +96242,12 @@
96464	96242	state.addr = 890787671342055424LLU; // varopen___
96465	96243	break;
96466	96244	}
96467		- case 18446744073709546040LLU: // 99999998m2'''''''''''''''
	96245	+ case 18446744073709546048LLU: // 99999998n_'''''''''''''''
96468	96246	{
96469		- state.addr = 18446744073709546041LLU; // 99999998m3'''''''''''''''
	96247	+ state.addr = 18446744073709546049LLU; // 99999998nA'''''''''''''''
96470	96248	break;
96471	96249	}
96472		- case 18446744073709546041LLU: // 99999998m3'''''''''''''''
	96250	+ case 18446744073709546049LLU: // 99999998nA'''''''''''''''
96473	96251	{
96474	96252	fprintf(stdout, "%s", "0");
96475	96253	{

		@@ -96496,7 +96274,7 @@
96496	96274	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96497	96275	}
96498	96276	// 5LLU
96499		- uint64_t return_to = 18446744073709546038LLU;
	96277	+ uint64_t return_to = 18446744073709546046LLU;
96500	96278	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96501	96279	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96502	96280	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96505,12 +96283,12 @@
96505	96283	state.addr = 890786842582581248LLU; // varclose__
96506	96284	break;
96507	96285	}
96508		- case 18446744073709546038LLU: // 99999998m0'''''''''''''''
	96286	+ case 18446744073709546046LLU: // 99999998m8'''''''''''''''
96509	96287	{
96510		- state.addr = 18446744073709546039LLU; // 99999998m1'''''''''''''''
	96288	+ state.addr = 18446744073709546047LLU; // 99999998m9'''''''''''''''
96511	96289	break;
96512	96290	}
96513		- case 18446744073709546039LLU: // 99999998m1'''''''''''''''
	96291	+ case 18446744073709546047LLU: // 99999998m9'''''''''''''''
96514	96292	{
96515	96293	{
96516	96294	uint64_t arg = 0LLU;

		@@ -96525,10 +96303,10 @@
96525	96303	uint64_t arg = 0;
96526	96304	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
96527	96305	}
96528		- state.addr = 18446744073709546037LLU; // 99999998mz'''''''''''''''
	96306	+ state.addr = 18446744073709546045LLU; // 99999998m7'''''''''''''''
96529	96307	break;
96530	96308	}
96531		- case 18446744073709546037LLU: // 99999998mz'''''''''''''''
	96309	+ case 18446744073709546045LLU: // 99999998m7'''''''''''''''
96532	96310	{
96533	96311	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
96534	96312	{

		@@ -96535,7 +96313,7 @@
96535	96313	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
96536	96314	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
96537	96315	{
96538		- state.addr = 18446744073709546036LLU; // 99999998my'''''''''''''''
	96316	+ state.addr = 18446744073709546044LLU; // 99999998m6'''''''''''''''
96539	96317	break;
96540	96318	}
96541	96319	}

		@@ -96566,7 +96344,7 @@
96566	96344	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96567	96345	}
96568	96346	// 4LLU
96569		- uint64_t return_to = 18446744073709546034LLU;
	96347	+ uint64_t return_to = 18446744073709546042LLU;
96570	96348	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96571	96349	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96572	96350	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96575,12 +96353,12 @@
96575	96353	state.addr = 587881363956563968LLU; // emitvar___
96576	96354	break;
96577	96355	}
96578		- case 18446744073709546034LLU: // 99999998mw'''''''''''''''
	96356	+ case 18446744073709546042LLU: // 99999998m4'''''''''''''''
96579	96357	{
96580		- state.addr = 18446744073709546035LLU; // 99999998mx'''''''''''''''
	96358	+ state.addr = 18446744073709546043LLU; // 99999998m5'''''''''''''''
96581	96359	break;
96582	96360	}
96583		- case 18446744073709546035LLU: // 99999998mx'''''''''''''''
	96361	+ case 18446744073709546043LLU: // 99999998m5'''''''''''''''
96584	96362	{
96585	96363	fprintf(stdout, "%s", " = tree_pop_move(&heap, ");
96586	96364	{

		@@ -96591,7 +96369,7 @@
96591	96369	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96592	96370	}
96593	96371	// 1LLU
96594		- uint64_t return_to = 18446744073709546032LLU;
	96372	+ uint64_t return_to = 18446744073709546040LLU;
96595	96373	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96596	96374	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96597	96375	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96600,12 +96378,12 @@
96600	96378	state.addr = 787446708198178816LLU; // printnr___
96601	96379	break;
96602	96380	}
96603		- case 18446744073709546032LLU: // 99999998mu'''''''''''''''
	96381	+ case 18446744073709546040LLU: // 99999998m2'''''''''''''''
96604	96382	{
96605		- state.addr = 18446744073709546033LLU; // 99999998mv'''''''''''''''
	96383	+ state.addr = 18446744073709546041LLU; // 99999998m3'''''''''''''''
96606	96384	break;
96607	96385	}
96608		- case 18446744073709546033LLU: // 99999998mv'''''''''''''''
	96386	+ case 18446744073709546041LLU: // 99999998m3'''''''''''''''
96609	96387	{
96610	96388	fprintf(stdout, "%s", ", &");
96611	96389	{

		@@ -96628,7 +96406,7 @@
96628	96406	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96629	96407	}
96630	96408	// 4LLU
96631		- uint64_t return_to = 18446744073709546030LLU;
	96409	+ uint64_t return_to = 18446744073709546038LLU;
96632	96410	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96633	96411	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96634	96412	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96637,12 +96415,12 @@
96637	96415	state.addr = 587881359725559808LLU; // emitref___
96638	96416	break;
96639	96417	}
96640		- case 18446744073709546030LLU: // 99999998ms'''''''''''''''
	96418	+ case 18446744073709546038LLU: // 99999998m0'''''''''''''''
96641	96419	{
96642		- state.addr = 18446744073709546031LLU; // 99999998mt'''''''''''''''
	96420	+ state.addr = 18446744073709546039LLU; // 99999998m1'''''''''''''''
96643	96421	break;
96644	96422	}
96645		- case 18446744073709546031LLU: // 99999998mt'''''''''''''''
	96423	+ case 18446744073709546039LLU: // 99999998m1'''''''''''''''
96646	96424	{
96647	96425	fprintf(stdout, "%s", ");");
96648	96426	{

		@@ -96685,7 +96463,7 @@
96685	96463	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96686	96464	}
96687	96465	// 9LLU
96688		- uint64_t return_to = 18446744073709546028LLU;
	96466	+ uint64_t return_to = 18446744073709546036LLU;
96689	96467	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96690	96468	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96691	96469	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96694,12 +96472,12 @@
96694	96472	state.addr = 587881344696777536LLU; // emitdestr_
96695	96473	break;
96696	96474	}
96697		- case 18446744073709546028LLU: // 99999998mq'''''''''''''''
	96475	+ case 18446744073709546036LLU: // 99999998my'''''''''''''''
96698	96476	{
96699		- state.addr = 18446744073709546029LLU; // 99999998mr'''''''''''''''
	96477	+ state.addr = 18446744073709546037LLU; // 99999998mz'''''''''''''''
96700	96478	break;
96701	96479	}
96702		- case 18446744073709546029LLU: // 99999998mr'''''''''''''''
	96480	+ case 18446744073709546037LLU: // 99999998mz'''''''''''''''
96703	96481	{
96704	96482	--/elemcount_/*LOCAL_ACCESS(heap.data, 19LLU, 15LLU);
96705	96483	// variable u64 paridx____ goes out of scope

		@@ -96707,10 +96485,10 @@
96707	96485	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx____ at 19
96708	96486	// parameter-reference elemdef___ elemtype__ goes out of scope
96709	96487	// parameter list<elemdef___> defpars___ goes out of scope
96710		- state.addr = 18446744073709546037LLU; // 99999998mz'''''''''''''''
	96488	+ state.addr = 18446744073709546045LLU; // 99999998m7'''''''''''''''
96711	96489	break;
96712	96490	}
96713		- case 18446744073709546036LLU: // 99999998my'''''''''''''''
	96491	+ case 18446744073709546044LLU: // 99999998m6'''''''''''''''
96714	96492	{
96715	96493	fprintf(stdout, "%s", "\n // RELEASE temporary destructor-variable");
96716	96494	{

		@@ -96737,7 +96515,7 @@
96737	96515	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96738	96516	}
96739	96517	// 4LLU
96740		- uint64_t return_to = 18446744073709546025LLU;
	96518	+ uint64_t return_to = 18446744073709546033LLU;
96741	96519	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96742	96520	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96743	96521	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96746,20 +96524,20 @@
96746	96524	state.addr = 587881357748664875LLU; // emitpoptmp
96747	96525	break;
96748	96526	}
96749		- case 18446744073709546025LLU: // 99999998mn'''''''''''''''
	96527	+ case 18446744073709546033LLU: // 99999998mv'''''''''''''''
96750	96528	{
96751		- state.addr = 18446744073709546026LLU; // 99999998mo'''''''''''''''
	96529	+ state.addr = 18446744073709546034LLU; // 99999998mw'''''''''''''''
96752	96530	break;
96753	96531	}
96754		- case 18446744073709546026LLU: // 99999998mo'''''''''''''''
	96532	+ case 18446744073709546034LLU: // 99999998mw'''''''''''''''
96755	96533	{
96756	96534	// variable u64 level_____ goes out of scope
96757	96535	// emitted destructur for type u64
96758	96536	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 17
96759		- state.addr = 18446744073709546027LLU; // 99999998mp'''''''''''''''
	96537	+ state.addr = 18446744073709546035LLU; // 99999998mx'''''''''''''''
96760	96538	break;
96761	96539	}
96762		- case 18446744073709546027LLU: // 99999998mp'''''''''''''''
	96540	+ case 18446744073709546035LLU: // 99999998mx'''''''''''''''
96763	96541	{
96764	96542	fprintf(stdout, "%s", "\n // RELEASE destructor-argument");
96765	96543	{

		@@ -96786,7 +96564,7 @@
96786	96564	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96787	96565	}
96788	96566	// 4LLU
96789		- uint64_t return_to = 18446744073709546022LLU;
	96567	+ uint64_t return_to = 18446744073709546030LLU;
96790	96568	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96791	96569	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96792	96570	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96795,20 +96573,20 @@
96795	96573	state.addr = 587881357748664875LLU; // emitpoptmp
96796	96574	break;
96797	96575	}
96798		- case 18446744073709546022LLU: // 99999998mk'''''''''''''''
	96576	+ case 18446744073709546030LLU: // 99999998ms'''''''''''''''
96799	96577	{
96800		- state.addr = 18446744073709546023LLU; // 99999998ml'''''''''''''''
	96578	+ state.addr = 18446744073709546031LLU; // 99999998mt'''''''''''''''
96801	96579	break;
96802	96580	}
96803		- case 18446744073709546023LLU: // 99999998ml'''''''''''''''
	96581	+ case 18446744073709546031LLU: // 99999998mt'''''''''''''''
96804	96582	{
96805	96583	// variable u64 level_____ goes out of scope
96806	96584	// emitted destructur for type u64
96807	96585	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 17
96808		- state.addr = 18446744073709546024LLU; // 99999998mm'''''''''''''''
	96586	+ state.addr = 18446744073709546032LLU; // 99999998mu'''''''''''''''
96809	96587	break;
96810	96588	}
96811		- case 18446744073709546024LLU: // 99999998mm'''''''''''''''
	96589	+ case 18446744073709546032LLU: // 99999998mu'''''''''''''''
96812	96590	{
96813	96591	{
96814	96592	uint64_t mainresult = heap.data[0].elem0;

		@@ -96826,7 +96604,7 @@
96826	96604	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96827	96605	}
96828	96606	// 3LLU
96829		- uint64_t return_to = 18446744073709546020LLU;
	96607	+ uint64_t return_to = 18446744073709546028LLU;
96830	96608	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96831	96609	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96832	96610	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96835,12 +96613,12 @@
96835	96613	state.addr = 587881353282000896LLU; // emitleave_
96836	96614	break;
96837	96615	}
96838		- case 18446744073709546020LLU: // 99999998mi'''''''''''''''
	96616	+ case 18446744073709546028LLU: // 99999998mq'''''''''''''''
96839	96617	{
96840		- state.addr = 18446744073709546021LLU; // 99999998mj'''''''''''''''
	96618	+ state.addr = 18446744073709546029LLU; // 99999998mr'''''''''''''''
96841	96619	break;
96842	96620	}
96843		- case 18446744073709546021LLU: // 99999998mj'''''''''''''''
	96621	+ case 18446744073709546029LLU: // 99999998mr'''''''''''''''
96844	96622	{
96845	96623	{
96846	96624	uint64_t mainresult = heap.data[0].elem0;

		@@ -96858,7 +96636,7 @@
96858	96636	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96859	96637	}
96860	96638	// 3LLU
96861		- uint64_t return_to = 18446744073709546018LLU;
	96639	+ uint64_t return_to = 18446744073709546026LLU;
96862	96640	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96863	96641	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96864	96642	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96867,12 +96645,12 @@
96867	96645	state.addr = 788334683946154816LLU; // pushdestr_
96868	96646	break;
96869	96647	}
96870		- case 18446744073709546018LLU: // 99999998mg'''''''''''''''
	96648	+ case 18446744073709546026LLU: // 99999998mo'''''''''''''''
96871	96649	{
96872		- state.addr = 18446744073709546019LLU; // 99999998mh'''''''''''''''
	96650	+ state.addr = 18446744073709546027LLU; // 99999998mp'''''''''''''''
96873	96651	break;
96874	96652	}
96875		- case 18446744073709546019LLU: // 99999998mh'''''''''''''''
	96653	+ case 18446744073709546027LLU: // 99999998mp'''''''''''''''
96876	96654	{
96877	96655	// variable u64 elemcount_ goes out of scope
96878	96656	// emitted destructur for type u64

		@@ -96889,10 +96667,10 @@
96889	96667	// variable u64 remainsize goes out of scope
96890	96668	// emitted destructur for type u64
96891	96669	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 12
96892		- state.addr = 18446744073709546046LLU; // 99999998m8'''''''''''''''
	96670	+ state.addr = 18446744073709546054LLU; // 99999998nF'''''''''''''''
96893	96671	break;
96894	96672	}
96895		- case 18446744073709546046LLU: // 99999998m8'''''''''''''''
	96673	+ case 18446744073709546054LLU: // 99999998nF'''''''''''''''
96896	96674	{
96897	96675	{
96898	96676	uint64_t arg = /sizelimit_/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU);

		@@ -96914,7 +96692,7 @@
96914	96692	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96915	96693	}
96916	96694	// 2LLU
96917		- uint64_t return_to = 18446744073709546015LLU;
	96695	+ uint64_t return_to = 18446744073709546023LLU;
96918	96696	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96919	96697	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96920	96698	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96923,12 +96701,12 @@
96923	96701	state.addr = 621679175848052672LLU; // gencompid_
96924	96702	break;
96925	96703	}
96926		- case 18446744073709546015LLU: // 99999998md'''''''''''''''
	96704	+ case 18446744073709546023LLU: // 99999998ml'''''''''''''''
96927	96705	{
96928		- state.addr = 18446744073709546016LLU; // 99999998me'''''''''''''''
	96706	+ state.addr = 18446744073709546024LLU; // 99999998mm'''''''''''''''
96929	96707	break;
96930	96708	}
96931		- case 18446744073709546016LLU: // 99999998me'''''''''''''''
	96709	+ case 18446744073709546024LLU: // 99999998mm'''''''''''''''
96932	96710	{
96933	96711	{
96934	96712	uint64_t mainresult = heap.data[0].elem0;

		@@ -96938,7 +96716,7 @@
96938	96716	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
96939	96717	}
96940	96718	// 1LLU
96941		- uint64_t return_to = 18446744073709546013LLU;
	96719	+ uint64_t return_to = 18446744073709546021LLU;
96942	96720	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96943	96721	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96944	96722	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96947,12 +96725,12 @@
96947	96725	state.addr = 587881345921715008LLU; // emitenter_
96948	96726	break;
96949	96727	}
96950		- case 18446744073709546013LLU: // 99999998mb'''''''''''''''
	96728	+ case 18446744073709546021LLU: // 99999998mj'''''''''''''''
96951	96729	{
96952		- state.addr = 18446744073709546014LLU; // 99999998mc'''''''''''''''
	96730	+ state.addr = 18446744073709546022LLU; // 99999998mk'''''''''''''''
96953	96731	break;
96954	96732	}
96955		- case 18446744073709546014LLU: // 99999998mc'''''''''''''''
	96733	+ case 18446744073709546022LLU: // 99999998mk'''''''''''''''
96956	96734	{
96957	96735	{
96958	96736	uint64_t arg = 3LLU;

		@@ -96970,7 +96748,7 @@
96970	96748	uint64_t mainresult = heap.data[0].elem0;
96971	96749	heap.data[0].elem0 = 0;
96972	96750	// 0LLU
96973		- uint64_t return_to = 18446744073709546011LLU;
	96751	+ uint64_t return_to = 18446744073709546019LLU;
96974	96752	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
96975	96753	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
96976	96754	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -96979,12 +96757,12 @@
96979	96757	state.addr = 890787671342055424LLU; // varopen___
96980	96758	break;
96981	96759	}
96982		- case 18446744073709546011LLU: // 99999998m$'''''''''''''''
	96760	+ case 18446744073709546019LLU: // 99999998mh'''''''''''''''
96983	96761	{
96984		- state.addr = 18446744073709546012LLU; // 99999998ma'''''''''''''''
	96762	+ state.addr = 18446744073709546020LLU; // 99999998mi'''''''''''''''
96985	96763	break;
96986	96764	}
96987		- case 18446744073709546012LLU: // 99999998ma'''''''''''''''
	96765	+ case 18446744073709546020LLU: // 99999998mi'''''''''''''''
96988	96766	{
96989	96767	fprintf(stdout, "%s", "0");
96990	96768	{

		@@ -97011,7 +96789,7 @@
97011	96789	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97012	96790	}
97013	96791	// 5LLU
97014		- uint64_t return_to = 18446744073709546009LLU;
	96792	+ uint64_t return_to = 18446744073709546017LLU;
97015	96793	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97016	96794	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97017	96795	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97020,12 +96798,12 @@
97020	96798	state.addr = 890786842582581248LLU; // varclose__
97021	96799	break;
97022	96800	}
97023		- case 18446744073709546009LLU: // 99999998mY'''''''''''''''
	96801	+ case 18446744073709546017LLU: // 99999998mf'''''''''''''''
97024	96802	{
97025		- state.addr = 18446744073709546010LLU; // 99999998mZ'''''''''''''''
	96803	+ state.addr = 18446744073709546018LLU; // 99999998mg'''''''''''''''
97026	96804	break;
97027	96805	}
97028		- case 18446744073709546010LLU: // 99999998mZ'''''''''''''''
	96806	+ case 18446744073709546018LLU: // 99999998mg'''''''''''''''
97029	96807	{
97030	96808	{
97031	96809	uint64_t arg = 0LLU;

		@@ -97035,7 +96813,7 @@
97035	96813	uint64_t mainresult = heap.data[0].elem0;
97036	96814	heap.data[0].elem0 = 0;
97037	96815	// 0LLU
97038		- uint64_t return_to = 18446744073709546007LLU;
	96816	+ uint64_t return_to = 18446744073709546015LLU;
97039	96817	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97040	96818	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97041	96819	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97044,12 +96822,12 @@
97044	96822	state.addr = 890787671342055424LLU; // varopen___
97045	96823	break;
97046	96824	}
97047		- case 18446744073709546007LLU: // 99999998mW'''''''''''''''
	96825	+ case 18446744073709546015LLU: // 99999998md'''''''''''''''
97048	96826	{
97049		- state.addr = 18446744073709546008LLU; // 99999998mX'''''''''''''''
	96827	+ state.addr = 18446744073709546016LLU; // 99999998me'''''''''''''''
97050	96828	break;
97051	96829	}
97052		- case 18446744073709546008LLU: // 99999998mX'''''''''''''''
	96830	+ case 18446744073709546016LLU: // 99999998me'''''''''''''''
97053	96831	{
97054	96832	fprintf(stdout, "%s", "0");
97055	96833	{

		@@ -97076,7 +96854,7 @@
97076	96854	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97077	96855	}
97078	96856	// 5LLU
97079		- uint64_t return_to = 18446744073709546005LLU;
	96857	+ uint64_t return_to = 18446744073709546013LLU;
97080	96858	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97081	96859	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97082	96860	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97085,12 +96863,12 @@
97085	96863	state.addr = 890786842582581248LLU; // varclose__
97086	96864	break;
97087	96865	}
97088		- case 18446744073709546005LLU: // 99999998mU'''''''''''''''
	96866	+ case 18446744073709546013LLU: // 99999998mb'''''''''''''''
97089	96867	{
97090		- state.addr = 18446744073709546006LLU; // 99999998mV'''''''''''''''
	96868	+ state.addr = 18446744073709546014LLU; // 99999998mc'''''''''''''''
97091	96869	break;
97092	96870	}
97093		- case 18446744073709546006LLU: // 99999998mV'''''''''''''''
	96871	+ case 18446744073709546014LLU: // 99999998mc'''''''''''''''
97094	96872	{
97095	96873	{
97096	96874	uint64_t arg = 0LLU;

		@@ -97117,7 +96895,7 @@
97117	96895	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97118	96896	}
97119	96897	// 2LLU
97120		- uint64_t return_to = 18446744073709546003LLU;
	96898	+ uint64_t return_to = 18446744073709546011LLU;
97121	96899	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97122	96900	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97123	96901	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97126,12 +96904,12 @@
97126	96904	state.addr = 517555828430075934LLU; // assign_dec
97127	96905	break;
97128	96906	}
97129		- case 18446744073709546003LLU: // 99999998mS'''''''''''''''
	96907	+ case 18446744073709546011LLU: // 99999998m$'''''''''''''''
97130	96908	{
97131		- state.addr = 18446744073709546004LLU; // 99999998mT'''''''''''''''
	96909	+ state.addr = 18446744073709546012LLU; // 99999998ma'''''''''''''''
97132	96910	break;
97133	96911	}
97134		- case 18446744073709546004LLU: // 99999998mT'''''''''''''''
	96912	+ case 18446744073709546012LLU: // 99999998ma'''''''''''''''
97135	96913	{
97136	96914	{
97137	96915	uint64_t arg = /defpars___/*LOCAL_ACCESS(heap.data, 20LLU, 9LLU);

		@@ -97141,10 +96919,10 @@
97141	96919	uint64_t arg = 0;
97142	96920	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
97143	96921	}
97144		- state.addr = 18446744073709546002LLU; // 99999998mR'''''''''''''''
	96922	+ state.addr = 18446744073709546010LLU; // 99999998mZ'''''''''''''''
97145	96923	break;
97146	96924	}
97147		- case 18446744073709546002LLU: // 99999998mR'''''''''''''''
	96925	+ case 18446744073709546010LLU: // 99999998mZ'''''''''''''''
97148	96926	{
97149	96927	if(!*LOCAL_ACCESS(heap.data, 22LLU, 20LLU))
97150	96928	{

		@@ -97151,7 +96929,7 @@
97151	96929	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 22
97152	96930	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
97153	96931	{
97154		- state.addr = 18446744073709546001LLU; // 99999998mQ'''''''''''''''
	96932	+ state.addr = 18446744073709546009LLU; // 99999998mY'''''''''''''''
97155	96933	break;
97156	96934	}
97157	96935	}

		@@ -97182,7 +96960,7 @@
97182	96960	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97183	96961	}
97184	96962	// 4LLU
97185		- uint64_t return_to = 18446744073709545999LLU;
	96963	+ uint64_t return_to = 18446744073709546007LLU;
97186	96964	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97187	96965	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97188	96966	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97191,12 +96969,12 @@
97191	96969	state.addr = 587881363956563968LLU; // emitvar___
97192	96970	break;
97193	96971	}
97194		- case 18446744073709545999LLU: // 99999998mO'''''''''''''''
	96972	+ case 18446744073709546007LLU: // 99999998mW'''''''''''''''
97195	96973	{
97196		- state.addr = 18446744073709546000LLU; // 99999998mP'''''''''''''''
	96974	+ state.addr = 18446744073709546008LLU; // 99999998mX'''''''''''''''
97197	96975	break;
97198	96976	}
97199		- case 18446744073709546000LLU: // 99999998mP'''''''''''''''
	96977	+ case 18446744073709546008LLU: // 99999998mX'''''''''''''''
97200	96978	{
97201	96979	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, ");
97202	96980	{

		@@ -97207,7 +96985,7 @@
97207	96985	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97208	96986	}
97209	96987	// 1LLU
97210		- uint64_t return_to = 18446744073709545997LLU;
	96988	+ uint64_t return_to = 18446744073709546005LLU;
97211	96989	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97212	96990	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97213	96991	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97216,12 +96994,12 @@
97216	96994	state.addr = 787446708198178816LLU; // printnr___
97217	96995	break;
97218	96996	}
97219		- case 18446744073709545997LLU: // 99999998mM'''''''''''''''
	96997	+ case 18446744073709546005LLU: // 99999998mU'''''''''''''''
97220	96998	{
97221		- state.addr = 18446744073709545998LLU; // 99999998mN'''''''''''''''
	96999	+ state.addr = 18446744073709546006LLU; // 99999998mV'''''''''''''''
97222	97000	break;
97223	97001	}
97224		- case 18446744073709545998LLU: // 99999998mN'''''''''''''''
	97002	+ case 18446744073709546006LLU: // 99999998mV'''''''''''''''
97225	97003	{
97226	97004	fprintf(stdout, "%s", ", ");
97227	97005	{

		@@ -97244,7 +97022,7 @@
97244	97022	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97245	97023	}
97246	97024	// 4LLU
97247		- uint64_t return_to = 18446744073709545995LLU;
	97025	+ uint64_t return_to = 18446744073709546003LLU;
97248	97026	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97249	97027	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97250	97028	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97253,12 +97031,12 @@
97253	97031	state.addr = 587881363956563968LLU; // emitvar___
97254	97032	break;
97255	97033	}
97256		- case 18446744073709545995LLU: // 99999998mK'''''''''''''''
	97034	+ case 18446744073709546003LLU: // 99999998mS'''''''''''''''
97257	97035	{
97258		- state.addr = 18446744073709545996LLU; // 99999998mL'''''''''''''''
	97036	+ state.addr = 18446744073709546004LLU; // 99999998mT'''''''''''''''
97259	97037	break;
97260	97038	}
97261		- case 18446744073709545996LLU: // 99999998mL'''''''''''''''
	97039	+ case 18446744073709546004LLU: // 99999998mT'''''''''''''''
97262	97040	{
97263	97041	fprintf(stdout, "%s", ", ");
97264	97042	{

		@@ -97269,7 +97047,7 @@
97269	97047	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97270	97048	}
97271	97049	// 1LLU
97272		- uint64_t return_to = 18446744073709545993LLU;
	97050	+ uint64_t return_to = 18446744073709546001LLU;
97273	97051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97274	97052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97275	97053	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97278,12 +97056,12 @@
97278	97056	state.addr = 787446708198178816LLU; // printnr___
97279	97057	break;
97280	97058	}
97281		- case 18446744073709545993LLU: // 99999998mI'''''''''''''''
	97059	+ case 18446744073709546001LLU: // 99999998mQ'''''''''''''''
97282	97060	{
97283		- state.addr = 18446744073709545994LLU; // 99999998mJ'''''''''''''''
	97061	+ state.addr = 18446744073709546002LLU; // 99999998mR'''''''''''''''
97284	97062	break;
97285	97063	}
97286		- case 18446744073709545994LLU: // 99999998mJ'''''''''''''''
	97064	+ case 18446744073709546002LLU: // 99999998mR'''''''''''''''
97287	97065	{
97288	97066	fprintf(stdout, "%s", ");");
97289	97067	{

		@@ -97311,7 +97089,7 @@
97311	97089	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97312	97090	}
97313	97091	// 4LLU
97314		- uint64_t return_to = 18446744073709545991LLU;
	97092	+ uint64_t return_to = 18446744073709545999LLU;
97315	97093	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97316	97094	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97317	97095	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97320,12 +97098,12 @@
97320	97098	state.addr = 587881363956563968LLU; // emitvar___
97321	97099	break;
97322	97100	}
97323		- case 18446744073709545991LLU: // 99999998mG'''''''''''''''
	97101	+ case 18446744073709545999LLU: // 99999998mO'''''''''''''''
97324	97102	{
97325		- state.addr = 18446744073709545992LLU; // 99999998mH'''''''''''''''
	97103	+ state.addr = 18446744073709546000LLU; // 99999998mP'''''''''''''''
97326	97104	break;
97327	97105	}
97328		- case 18446744073709545992LLU: // 99999998mH'''''''''''''''
	97106	+ case 18446744073709546000LLU: // 99999998mP'''''''''''''''
97329	97107	{
97330	97108	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, ");
97331	97109	{

		@@ -97336,7 +97114,7 @@
97336	97114	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97337	97115	}
97338	97116	// 1LLU
97339		- uint64_t return_to = 18446744073709545989LLU;
	97117	+ uint64_t return_to = 18446744073709545997LLU;
97340	97118	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97341	97119	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97342	97120	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97345,12 +97123,12 @@
97345	97123	state.addr = 787446708198178816LLU; // printnr___
97346	97124	break;
97347	97125	}
97348		- case 18446744073709545989LLU: // 99999998mE'''''''''''''''
	97126	+ case 18446744073709545997LLU: // 99999998mM'''''''''''''''
97349	97127	{
97350		- state.addr = 18446744073709545990LLU; // 99999998mF'''''''''''''''
	97128	+ state.addr = 18446744073709545998LLU; // 99999998mN'''''''''''''''
97351	97129	break;
97352	97130	}
97353		- case 18446744073709545990LLU: // 99999998mF'''''''''''''''
	97131	+ case 18446744073709545998LLU: // 99999998mN'''''''''''''''
97354	97132	{
97355	97133	fprintf(stdout, "%s", ", ");
97356	97134	{

		@@ -97373,7 +97151,7 @@
97373	97151	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97374	97152	}
97375	97153	// 4LLU
97376		- uint64_t return_to = 18446744073709545987LLU;
	97154	+ uint64_t return_to = 18446744073709545995LLU;
97377	97155	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97378	97156	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97379	97157	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97382,12 +97160,12 @@
97382	97160	state.addr = 587881363956563968LLU; // emitvar___
97383	97161	break;
97384	97162	}
97385		- case 18446744073709545987LLU: // 99999998mC'''''''''''''''
	97163	+ case 18446744073709545995LLU: // 99999998mK'''''''''''''''
97386	97164	{
97387		- state.addr = 18446744073709545988LLU; // 99999998mD'''''''''''''''
	97165	+ state.addr = 18446744073709545996LLU; // 99999998mL'''''''''''''''
97388	97166	break;
97389	97167	}
97390		- case 18446744073709545988LLU: // 99999998mD'''''''''''''''
	97168	+ case 18446744073709545996LLU: // 99999998mL'''''''''''''''
97391	97169	{
97392	97170	fprintf(stdout, "%s", ", ");
97393	97171	{

		@@ -97398,7 +97176,7 @@
97398	97176	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97399	97177	}
97400	97178	// 1LLU
97401		- uint64_t return_to = 18446744073709545985LLU;
	97179	+ uint64_t return_to = 18446744073709545993LLU;
97402	97180	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97403	97181	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97404	97182	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97407,12 +97185,12 @@
97407	97185	state.addr = 787446708198178816LLU; // printnr___
97408	97186	break;
97409	97187	}
97410		- case 18446744073709545985LLU: // 99999998mA'''''''''''''''
	97188	+ case 18446744073709545993LLU: // 99999998mI'''''''''''''''
97411	97189	{
97412		- state.addr = 18446744073709545986LLU; // 99999998mB'''''''''''''''
	97190	+ state.addr = 18446744073709545994LLU; // 99999998mJ'''''''''''''''
97413	97191	break;
97414	97192	}
97415		- case 18446744073709545986LLU: // 99999998mB'''''''''''''''
	97193	+ case 18446744073709545994LLU: // 99999998mJ'''''''''''''''
97416	97194	{
97417	97195	fprintf(stdout, "%s", ");");
97418	97196	{

		@@ -97487,7 +97265,7 @@
97487	97265	LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97488	97266	}
97489	97267	// 14LLU
97490		- uint64_t return_to = 18446744073709545982LLU;
	97268	+ uint64_t return_to = 18446744073709545990LLU;
97491	97269	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97492	97270	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 14LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97493	97271	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97496,12 +97274,12 @@
97496	97274	state.addr = 587881343789215744LLU; // emitcomp__
97497	97275	break;
97498	97276	}
97499		- case 18446744073709545982LLU: // 99999998l8'''''''''''''''
	97277	+ case 18446744073709545990LLU: // 99999998mF'''''''''''''''
97500	97278	{
97501		- state.addr = 18446744073709545983LLU; // 99999998l9'''''''''''''''
	97279	+ state.addr = 18446744073709545991LLU; // 99999998mG'''''''''''''''
97502	97280	break;
97503	97281	}
97504		- case 18446744073709545983LLU: // 99999998l9'''''''''''''''
	97282	+ case 18446744073709545991LLU: // 99999998mG'''''''''''''''
97505	97283	{
97506	97284	// variable u64 indirect2_ goes out of scope
97507	97285	// emitted destructur for type u64

		@@ -97512,10 +97290,10 @@
97512	97290	// variable u64 indirect__ goes out of scope
97513	97291	// emitted destructur for type u64
97514	97292	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference indirect__ at 25
97515		- state.addr = 18446744073709545984LLU; // 99999998m_'''''''''''''''
	97293	+ state.addr = 18446744073709545992LLU; // 99999998mH'''''''''''''''
97516	97294	break;
97517	97295	}
97518		- case 18446744073709545984LLU: // 99999998m_'''''''''''''''
	97296	+ case 18446744073709545992LLU: // 99999998mH'''''''''''''''
97519	97297	{
97520	97298	fprintf(stdout, "%s", "\n if(");
97521	97299	{

		@@ -97538,7 +97316,7 @@
97538	97316	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97539	97317	}
97540	97318	// 4LLU
97541		- uint64_t return_to = 18446744073709545980LLU;
	97319	+ uint64_t return_to = 18446744073709545988LLU;
97542	97320	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97543	97321	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97544	97322	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97547,12 +97325,12 @@
97547	97325	state.addr = 587881359725559808LLU; // emitref___
97548	97326	break;
97549	97327	}
97550		- case 18446744073709545980LLU: // 99999998l6'''''''''''''''
	97328	+ case 18446744073709545988LLU: // 99999998mD'''''''''''''''
97551	97329	{
97552		- state.addr = 18446744073709545981LLU; // 99999998l7'''''''''''''''
	97330	+ state.addr = 18446744073709545989LLU; // 99999998mE'''''''''''''''
97553	97331	break;
97554	97332	}
97555		- case 18446744073709545981LLU: // 99999998l7'''''''''''''''
	97333	+ case 18446744073709545989LLU: // 99999998mE'''''''''''''''
97556	97334	{
97557	97335	fprintf(stdout, "%s", "/result/)");
97558	97336	{

		@@ -97571,7 +97349,7 @@
97571	97349	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97572	97350	}
97573	97351	// 2LLU
97574		- uint64_t return_to = 18446744073709545977LLU;
	97352	+ uint64_t return_to = 18446744073709545985LLU;
97575	97353	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97576	97354	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97577	97355	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97580,20 +97358,20 @@
97580	97358	state.addr = 587881351406075392LLU; // emitjump2_
97581	97359	break;
97582	97360	}
97583		- case 18446744073709545977LLU: // 99999998l3'''''''''''''''
	97361	+ case 18446744073709545985LLU: // 99999998mA'''''''''''''''
97584	97362	{
97585		- state.addr = 18446744073709545978LLU; // 99999998l4'''''''''''''''
	97363	+ state.addr = 18446744073709545986LLU; // 99999998mB'''''''''''''''
97586	97364	break;
97587	97365	}
97588		- case 18446744073709545978LLU: // 99999998l4'''''''''''''''
	97366	+ case 18446744073709545986LLU: // 99999998mB'''''''''''''''
97589	97367	{
97590	97368	// variable u64 level_____ goes out of scope
97591	97369	// emitted destructur for type u64
97592	97370	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 25
97593		- state.addr = 18446744073709545979LLU; // 99999998l5'''''''''''''''
	97371	+ state.addr = 18446744073709545987LLU; // 99999998mC'''''''''''''''
97594	97372	break;
97595	97373	}
97596		- case 18446744073709545979LLU: // 99999998l5'''''''''''''''
	97374	+ case 18446744073709545987LLU: // 99999998mC'''''''''''''''
97597	97375	{
97598	97376	++/elemnr____/*LOCAL_ACCESS(heap.data, 24LLU, 18LLU);
97599	97377	// variable u64 paridx2___ goes out of scope

		@@ -97604,10 +97382,10 @@
97604	97382	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx1___ at 23
97605	97383	// parameter-reference elemdef___ elemtype__ goes out of scope
97606	97384	// parameter list<elemdef___> defpars___ goes out of scope
97607		- state.addr = 18446744073709546002LLU; // 99999998mR'''''''''''''''
	97385	+ state.addr = 18446744073709546010LLU; // 99999998mZ'''''''''''''''
97608	97386	break;
97609	97387	}
97610		- case 18446744073709546001LLU: // 99999998mQ'''''''''''''''
	97388	+ case 18446744073709546009LLU: // 99999998mY'''''''''''''''
97611	97389	{
97612	97390	{
97613	97391	uint64_t arg = 0LLU;

		@@ -97625,7 +97403,7 @@
97625	97403	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97626	97404	}
97627	97405	// 2LLU
97628		- uint64_t return_to = 18446744073709545974LLU;
	97406	+ uint64_t return_to = 18446744073709545982LLU;
97629	97407	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97630	97408	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97631	97409	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97634,20 +97412,20 @@
97634	97412	state.addr = 587881353215084992LLU; // emitlabel_
97635	97413	break;
97636	97414	}
97637		- case 18446744073709545974LLU: // 99999998l0'''''''''''''''
	97415	+ case 18446744073709545982LLU: // 99999998l8'''''''''''''''
97638	97416	{
97639		- state.addr = 18446744073709545975LLU; // 99999998l1'''''''''''''''
	97417	+ state.addr = 18446744073709545983LLU; // 99999998l9'''''''''''''''
97640	97418	break;
97641	97419	}
97642		- case 18446744073709545975LLU: // 99999998l1'''''''''''''''
	97420	+ case 18446744073709545983LLU: // 99999998l9'''''''''''''''
97643	97421	{
97644	97422	// variable u64 level_____ goes out of scope
97645	97423	// emitted destructur for type u64
97646	97424	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 21
97647		- state.addr = 18446744073709545976LLU; // 99999998l2'''''''''''''''
	97425	+ state.addr = 18446744073709545984LLU; // 99999998m_'''''''''''''''
97648	97426	break;
97649	97427	}
97650		- case 18446744073709545976LLU: // 99999998l2'''''''''''''''
	97428	+ case 18446744073709545984LLU: // 99999998m_'''''''''''''''
97651	97429	{
97652	97430	fprintf(stdout, "%s", "\n // RELEASE temporary comparator-variables\n");
97653	97431	{

		@@ -97674,7 +97452,7 @@
97674	97452	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97675	97453	}
97676	97454	// 4LLU
97677		- uint64_t return_to = 18446744073709545971LLU;
	97455	+ uint64_t return_to = 18446744073709545979LLU;
97678	97456	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97679	97457	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97680	97458	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97683,12 +97461,12 @@
97683	97461	state.addr = 587881357748664875LLU; // emitpoptmp
97684	97462	break;
97685	97463	}
97686		- case 18446744073709545971LLU: // 99999998lx'''''''''''''''
	97464	+ case 18446744073709545979LLU: // 99999998l5'''''''''''''''
97687	97465	{
97688		- state.addr = 18446744073709545972LLU; // 99999998ly'''''''''''''''
	97466	+ state.addr = 18446744073709545980LLU; // 99999998l6'''''''''''''''
97689	97467	break;
97690	97468	}
97691		- case 18446744073709545972LLU: // 99999998ly'''''''''''''''
	97469	+ case 18446744073709545980LLU: // 99999998l6'''''''''''''''
97692	97470	{
97693	97471	{
97694	97472	uint64_t mainresult = heap.data[0].elem0;

		@@ -97710,7 +97488,7 @@
97710	97488	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97711	97489	}
97712	97490	// 4LLU
97713		- uint64_t return_to = 18446744073709545969LLU;
	97491	+ uint64_t return_to = 18446744073709545977LLU;
97714	97492	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97715	97493	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97716	97494	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97719,20 +97497,20 @@
97719	97497	state.addr = 587881357748664875LLU; // emitpoptmp
97720	97498	break;
97721	97499	}
97722		- case 18446744073709545969LLU: // 99999998lv'''''''''''''''
	97500	+ case 18446744073709545977LLU: // 99999998l3'''''''''''''''
97723	97501	{
97724		- state.addr = 18446744073709545970LLU; // 99999998lw'''''''''''''''
	97502	+ state.addr = 18446744073709545978LLU; // 99999998l4'''''''''''''''
97725	97503	break;
97726	97504	}
97727		- case 18446744073709545970LLU: // 99999998lw'''''''''''''''
	97505	+ case 18446744073709545978LLU: // 99999998l4'''''''''''''''
97728	97506	{
97729	97507	// variable u64 level_____ goes out of scope
97730	97508	// emitted destructur for type u64
97731	97509	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 21
97732		- state.addr = 18446744073709545973LLU; // 99999998lz'''''''''''''''
	97510	+ state.addr = 18446744073709545981LLU; // 99999998l7'''''''''''''''
97733	97511	break;
97734	97512	}
97735		- case 18446744073709545973LLU: // 99999998lz'''''''''''''''
	97513	+ case 18446744073709545981LLU: // 99999998l7'''''''''''''''
97736	97514	{
97737	97515	fprintf(stdout, "%s", "\n // RELEASE comparator-arguments\n");
97738	97516	{

		@@ -97759,7 +97537,7 @@
97759	97537	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97760	97538	}
97761	97539	// 4LLU
97762		- uint64_t return_to = 18446744073709545966LLU;
	97540	+ uint64_t return_to = 18446744073709545974LLU;
97763	97541	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97764	97542	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97765	97543	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97768,12 +97546,12 @@
97768	97546	state.addr = 587881357748664875LLU; // emitpoptmp
97769	97547	break;
97770	97548	}
97771		- case 18446744073709545966LLU: // 99999998ls'''''''''''''''
	97549	+ case 18446744073709545974LLU: // 99999998l0'''''''''''''''
97772	97550	{
97773		- state.addr = 18446744073709545967LLU; // 99999998lt'''''''''''''''
	97551	+ state.addr = 18446744073709545975LLU; // 99999998l1'''''''''''''''
97774	97552	break;
97775	97553	}
97776		- case 18446744073709545967LLU: // 99999998lt'''''''''''''''
	97554	+ case 18446744073709545975LLU: // 99999998l1'''''''''''''''
97777	97555	{
97778	97556	{
97779	97557	uint64_t mainresult = heap.data[0].elem0;

		@@ -97795,7 +97573,7 @@
97795	97573	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97796	97574	}
97797	97575	// 4LLU
97798		- uint64_t return_to = 18446744073709545964LLU;
	97576	+ uint64_t return_to = 18446744073709545972LLU;
97799	97577	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97800	97578	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97801	97579	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97804,12 +97582,12 @@
97804	97582	state.addr = 587881357748664875LLU; // emitpoptmp
97805	97583	break;
97806	97584	}
97807		- case 18446744073709545964LLU: // 99999998lq'''''''''''''''
	97585	+ case 18446744073709545972LLU: // 99999998ly'''''''''''''''
97808	97586	{
97809		- state.addr = 18446744073709545965LLU; // 99999998lr'''''''''''''''
	97587	+ state.addr = 18446744073709545973LLU; // 99999998lz'''''''''''''''
97810	97588	break;
97811	97589	}
97812		- case 18446744073709545965LLU: // 99999998lr'''''''''''''''
	97590	+ case 18446744073709545973LLU: // 99999998lz'''''''''''''''
97813	97591	{
97814	97592	{
97815	97593	uint64_t mainresult = heap.data[0].elem0;

		@@ -97831,7 +97609,7 @@
97831	97609	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97832	97610	}
97833	97611	// 4LLU
97834		- uint64_t return_to = 18446744073709545962LLU;
	97612	+ uint64_t return_to = 18446744073709545970LLU;
97835	97613	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97836	97614	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97837	97615	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97840,20 +97618,20 @@
97840	97618	state.addr = 587881357748664875LLU; // emitpoptmp
97841	97619	break;
97842	97620	}
97843		- case 18446744073709545962LLU: // 99999998lo'''''''''''''''
	97621	+ case 18446744073709545970LLU: // 99999998lw'''''''''''''''
97844	97622	{
97845		- state.addr = 18446744073709545963LLU; // 99999998lp'''''''''''''''
	97623	+ state.addr = 18446744073709545971LLU; // 99999998lx'''''''''''''''
97846	97624	break;
97847	97625	}
97848		- case 18446744073709545963LLU: // 99999998lp'''''''''''''''
	97626	+ case 18446744073709545971LLU: // 99999998lx'''''''''''''''
97849	97627	{
97850	97628	// variable u64 level_____ goes out of scope
97851	97629	// emitted destructur for type u64
97852	97630	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 21
97853		- state.addr = 18446744073709545968LLU; // 99999998lu'''''''''''''''
	97631	+ state.addr = 18446744073709545976LLU; // 99999998l2'''''''''''''''
97854	97632	break;
97855	97633	}
97856		- case 18446744073709545968LLU: // 99999998lu'''''''''''''''
	97634	+ case 18446744073709545976LLU: // 99999998l2'''''''''''''''
97857	97635	{
97858	97636	{
97859	97637	uint64_t mainresult = heap.data[0].elem0;

		@@ -97871,7 +97649,7 @@
97871	97649	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97872	97650	}
97873	97651	// 3LLU
97874		- uint64_t return_to = 18446744073709545960LLU;
	97652	+ uint64_t return_to = 18446744073709545968LLU;
97875	97653	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97876	97654	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97877	97655	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97880,12 +97658,12 @@
97880	97658	state.addr = 587881353282000896LLU; // emitleave_
97881	97659	break;
97882	97660	}
97883		- case 18446744073709545960LLU: // 99999998lm'''''''''''''''
	97661	+ case 18446744073709545968LLU: // 99999998lu'''''''''''''''
97884	97662	{
97885		- state.addr = 18446744073709545961LLU; // 99999998ln'''''''''''''''
	97663	+ state.addr = 18446744073709545969LLU; // 99999998lv'''''''''''''''
97886	97664	break;
97887	97665	}
97888		- case 18446744073709545961LLU: // 99999998ln'''''''''''''''
	97666	+ case 18446744073709545969LLU: // 99999998lv'''''''''''''''
97889	97667	{
97890	97668	{
97891	97669	uint64_t mainresult = heap.data[0].elem0;

		@@ -97903,7 +97681,7 @@
97903	97681	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
97904	97682	}
97905	97683	// 3LLU
97906		- uint64_t return_to = 18446744073709545958LLU;
	97684	+ uint64_t return_to = 18446744073709545966LLU;
97907	97685	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
97908	97686	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
97909	97687	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -97912,12 +97690,12 @@
97912	97690	state.addr = 788334683946154816LLU; // pushdestr_
97913	97691	break;
97914	97692	}
97915		- case 18446744073709545958LLU: // 99999998lk'''''''''''''''
	97693	+ case 18446744073709545966LLU: // 99999998ls'''''''''''''''
97916	97694	{
97917		- state.addr = 18446744073709545959LLU; // 99999998ll'''''''''''''''
	97695	+ state.addr = 18446744073709545967LLU; // 99999998lt'''''''''''''''
97918	97696	break;
97919	97697	}
97920		- case 18446744073709545959LLU: // 99999998ll'''''''''''''''
	97698	+ case 18446744073709545967LLU: // 99999998lt'''''''''''''''
97921	97699	{
97922	97700	// variable u64 skiplabel_ goes out of scope
97923	97701	// emitted destructur for type u64

		@@ -97946,10 +97724,10 @@
97946	97724	// variable u64 remainsize goes out of scope
97947	97725	// emitted destructur for type u64
97948	97726	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 12
97949		- state.addr = 18446744073709546017LLU; // 99999998mf'''''''''''''''
	97727	+ state.addr = 18446744073709546025LLU; // 99999998mn'''''''''''''''
97950	97728	break;
97951	97729	}
97952		- case 18446744073709546017LLU: // 99999998mf'''''''''''''''
	97730	+ case 18446744073709546025LLU: // 99999998mn'''''''''''''''
97953	97731	{
97954	97732	{
97955	97733	uint64_t arg = 0LLU;

		@@ -97963,10 +97741,10 @@
97963	97741	uint64_t arg = 0;
97964	97742	LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
97965	97743	}
97966		- state.addr = 18446744073709545957LLU; // 99999998lj'''''''''''''''
	97744	+ state.addr = 18446744073709545965LLU; // 99999998lr'''''''''''''''
97967	97745	break;
97968	97746	}
97969		- case 18446744073709545957LLU: // 99999998lj'''''''''''''''
	97747	+ case 18446744073709545965LLU: // 99999998lr'''''''''''''''
97970	97748	{
97971	97749	if(!*LOCAL_ACCESS(heap.data, 14LLU, 12LLU))
97972	97750	{

		@@ -97973,7 +97751,7 @@
97973	97751	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 14
97974	97752	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
97975	97753	{
97976		- state.addr = 18446744073709545956LLU; // 99999998li'''''''''''''''
	97754	+ state.addr = 18446744073709545964LLU; // 99999998lq'''''''''''''''
97977	97755	break;
97978	97756	}
97979	97757	}

		@@ -97999,7 +97777,7 @@
97999	97777	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98000	97778	}
98001	97779	// 2LLU
98002		- uint64_t return_to = 18446744073709545954LLU;
	97780	+ uint64_t return_to = 18446744073709545962LLU;
98003	97781	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98004	97782	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98005	97783	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98008,12 +97786,12 @@
98008	97786	state.addr = 861504787186880512LLU; // typemain__
98009	97787	break;
98010	97788	}
98011		- case 18446744073709545954LLU: // 99999998lg'''''''''''''''
	97789	+ case 18446744073709545962LLU: // 99999998lo'''''''''''''''
98012	97790	{
98013		- state.addr = 18446744073709545955LLU; // 99999998lh'''''''''''''''
	97791	+ state.addr = 18446744073709545963LLU; // 99999998lp'''''''''''''''
98014	97792	break;
98015	97793	}
98016		- case 18446744073709545955LLU: // 99999998lh'''''''''''''''
	97794	+ case 18446744073709545963LLU: // 99999998lp'''''''''''''''
98017	97795	{
98018	97796	{
98019	97797	uint64_t mainresult = heap.data[0].elem0;

		@@ -98035,7 +97813,7 @@
98035	97813	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98036	97814	}
98037	97815	// 4LLU
98038		- uint64_t return_to = 18446744073709545952LLU;
	97816	+ uint64_t return_to = 18446744073709545960LLU;
98039	97817	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98040	97818	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98041	97819	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98044,12 +97822,12 @@
98044	97822	state.addr = 861504789552170795LLU; // typeonheap
98045	97823	break;
98046	97824	}
98047		- case 18446744073709545952LLU: // 99999998le'''''''''''''''
	97825	+ case 18446744073709545960LLU: // 99999998lm'''''''''''''''
98048	97826	{
98049		- state.addr = 18446744073709545953LLU; // 99999998lf'''''''''''''''
	97827	+ state.addr = 18446744073709545961LLU; // 99999998ln'''''''''''''''
98050	97828	break;
98051	97829	}
98052		- case 18446744073709545953LLU: // 99999998lf'''''''''''''''
	97830	+ case 18446744073709545961LLU: // 99999998ln'''''''''''''''
98053	97831	{
98054	97832	/sumheapsz_/LOCAL_ACCESS(heap.data, 16LLU, 11LLU) = /sumheapsz_/LOCAL_ACCESS(heap.data, 16LLU, 11LLU) + /reqsize___/*LOCAL_ACCESS(heap.data, 16LLU, 14LLU);
98055	97833	++/sumheapsz_/*LOCAL_ACCESS(heap.data, 16LLU, 11LLU);

		@@ -98061,10 +97839,10 @@
98061	97839	(void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reqsize___ at 15
98062	97840	// parameter-reference elemdef___ elemtype__ goes out of scope
98063	97841	// parameter list<elemdef___> defpars___ goes out of scope
98064		- state.addr = 18446744073709545957LLU; // 99999998lj'''''''''''''''
	97842	+ state.addr = 18446744073709545965LLU; // 99999998lr'''''''''''''''
98065	97843	break;
98066	97844	}
98067		- case 18446744073709545956LLU: // 99999998li'''''''''''''''
	97845	+ case 18446744073709545964LLU: // 99999998lq'''''''''''''''
98068	97846	{
98069	97847	--/sumheapsz_/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU);
98070	97848	{

		@@ -98087,7 +97865,7 @@
98087	97865	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98088	97866	}
98089	97867	// 4LLU
98090		- uint64_t return_to = 18446744073709545950LLU;
	97868	+ uint64_t return_to = 18446744073709545958LLU;
98091	97869	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98092	97870	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98093	97871	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98096,12 +97874,12 @@
98096	97874	state.addr = 788334700303681455LLU; // pushstruct
98097	97875	break;
98098	97876	}
98099		- case 18446744073709545950LLU: // 99999998lc'''''''''''''''
	97877	+ case 18446744073709545958LLU: // 99999998lk'''''''''''''''
98100	97878	{
98101		- state.addr = 18446744073709545951LLU; // 99999998ld'''''''''''''''
	97879	+ state.addr = 18446744073709545959LLU; // 99999998ll'''''''''''''''
98102	97880	break;
98103	97881	}
98104		- case 18446744073709545951LLU: // 99999998ld'''''''''''''''
	97882	+ case 18446744073709545959LLU: // 99999998ll'''''''''''''''
98105	97883	{
98106	97884	// variable u64 sumheapsz_ goes out of scope
98107	97885	// emitted destructur for type u64

		@@ -98116,14 +97894,14 @@
98116	97894	uint64_t arg = 0;
98117	97895	LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
98118	97896	}
98119		- state.addr = 18446744073709545948LLU; // 99999998la'''''''''''''''
	97897	+ state.addr = 18446744073709545956LLU; // 99999998li'''''''''''''''
98120	97898	break;
98121	97899	}
98122		- case 18446744073709545948LLU: // 99999998la'''''''''''''''
	97900	+ case 18446744073709545956LLU: // 99999998li'''''''''''''''
98123	97901	{
98124	97902	if(!LOCAL_ACCESS(heap.data, 11LLU, 9LLU)/list*/)
98125	97903	{
98126		- state.addr = 18446744073709545949LLU; // 99999998lb'''''''''''''''
	97904	+ state.addr = 18446744073709545957LLU; // 99999998lj'''''''''''''''
98127	97905	break;
98128	97906	}
98129	97907	LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 11LLU, 9LLU)/list/, 3);

		@@ -98135,7 +97913,7 @@
98135	97913	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98136	97914	}
98137	97915	// 1LLU
98138		- uint64_t return_to = 18446744073709545947LLU;
	97916	+ uint64_t return_to = 18446744073709545955LLU;
98139	97917	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98140	97918	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98141	97919	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98144,21 +97922,21 @@
98144	97922	state.addr = 587581796494083780LLU; // elemdef_$D
98145	97923	break;
98146	97924	}
98147		- case 18446744073709545947LLU: // 99999998l$'''''''''''''''
	97925	+ case 18446744073709545955LLU: // 99999998lh'''''''''''''''
98148	97926	{
98149		- state.addr = 18446744073709545948LLU; // 99999998la'''''''''''''''
	97927	+ state.addr = 18446744073709545956LLU; // 99999998li'''''''''''''''
98150	97928	break;
98151	97929	}
98152		- case 18446744073709545949LLU: // 99999998lb'''''''''''''''
	97930	+ case 18446744073709545957LLU: // 99999998lj'''''''''''''''
98153	97931	{
98154	97932	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
98155	97933	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defpars___ at 10
98156	97934	heap.availilable_size_for_dynamic_objects += 0LLU;
98157	97935	heap.availilable_size_for_dynamic_objects += 0LLU;
98158		- state.addr = 18446744073709545946LLU; // 99999998lZ'''''''''''''''
	97936	+ state.addr = 18446744073709545954LLU; // 99999998lg'''''''''''''''
98159	97937	break;
98160	97938	}
98161		- case 18446744073709546058LLU: // 99999998nJ'''''''''''''''
	97939	+ case 18446744073709546066LLU: // 99999998nR'''''''''''''''
98162	97940	{
98163	97941	{
98164	97942	uint64_t arg = 876392862416109568LLU;

		@@ -98165,10 +97943,10 @@
98165	97943	LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
98166	97944	}
98167	97945	/isunion___/LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = /isunion___/LOCAL_ACCESS(heap.data, 10LLU, 9LLU) == /id________/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
98168		- state.addr = /isunion___/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545945LLU : 18446744073709545944LLU;
	97946	+ state.addr = /isunion___/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU) ? 18446744073709545953LLU : 18446744073709545952LLU;
98169	97947	break;
98170	97948	}
98171		- case 18446744073709545945LLU: // 99999998lY'''''''''''''''
	97949	+ case 18446744073709545953LLU: // 99999998lf'''''''''''''''
98172	97950	{
98173	97951	{
98174	97952	uint64_t arg = 0LLU;

		@@ -98182,7 +97960,7 @@
98182	97960	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98183	97961	}
98184	97962	// 1LLU
98185		- uint64_t return_to = 18446744073709545942LLU;
	97963	+ uint64_t return_to = 18446744073709545950LLU;
98186	97964	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98187	97965	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98188	97966	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98191,12 +97969,12 @@
98191	97969	state.addr = 839519719621918720LLU; // skipws____
98192	97970	break;
98193	97971	}
98194		- case 18446744073709545942LLU: // 99999998lV'''''''''''''''
	97972	+ case 18446744073709545950LLU: // 99999998lc'''''''''''''''
98195	97973	{
98196		- state.addr = 18446744073709545943LLU; // 99999998lW'''''''''''''''
	97974	+ state.addr = 18446744073709545951LLU; // 99999998ld'''''''''''''''
98197	97975	break;
98198	97976	}
98199		- case 18446744073709545943LLU: // 99999998lW'''''''''''''''
	97977	+ case 18446744073709545951LLU: // 99999998ld'''''''''''''''
98200	97978	{
98201	97979	/union_id__/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 11LLU, 5LLU)));
98202	97980	{

		@@ -98219,7 +97997,7 @@
98219	97997	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98220	97998	}
98221	97999	// 3LLU
98222		- uint64_t return_to = 18446744073709545939LLU;
	98000	+ uint64_t return_to = 18446744073709545947LLU;
98223	98001	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98224	98002	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98225	98003	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98228,17 +98006,17 @@
98228	98006	state.addr = 590977518136150752LLU; // existstype
98229	98007	break;
98230	98008	}
98231		- case 18446744073709545939LLU: // 99999998lS'''''''''''''''
	98009	+ case 18446744073709545947LLU: // 99999998l$'''''''''''''''
98232	98010	{
98233		- state.addr = 18446744073709545940LLU; // 99999998lT'''''''''''''''
	98011	+ state.addr = 18446744073709545948LLU; // 99999998la'''''''''''''''
98234	98012	break;
98235	98013	}
98236		- case 18446744073709545940LLU: // 99999998lT'''''''''''''''
	98014	+ case 18446744073709545948LLU: // 99999998la'''''''''''''''
98237	98015	{
98238		- state.addr = /exists____/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709545938LLU : 18446744073709545937LLU;
	98016	+ state.addr = /exists____/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709545946LLU : 18446744073709545945LLU;
98239	98017	break;
98240	98018	}
98241		- case 18446744073709545938LLU: // 99999998lR'''''''''''''''
	98019	+ case 18446744073709545946LLU: // 99999998lZ'''''''''''''''
98242	98020	{
98243	98021	fprintf(stderr, "%s", "re-definition of union ");
98244	98022	printid(stderr, /union_id__/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU));

		@@ -98246,18 +98024,18 @@
98246	98024	fprintf(stderr, "%s\n", "");
98247	98025	exit(-1);
98248	98026	}
98249		- state.addr = 18446744073709545937LLU; // 99999998lQ'''''''''''''''
	98027	+ state.addr = 18446744073709545945LLU; // 99999998lY'''''''''''''''
98250	98028	break;
98251	98029	}
98252		- case 18446744073709545937LLU: // 99999998lQ'''''''''''''''
	98030	+ case 18446744073709545945LLU: // 99999998lY'''''''''''''''
98253	98031	{
98254	98032	// variable u64 exists____ goes out of scope
98255	98033	// emitted destructur for type u64
98256	98034	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference exists____ at 12
98257		- state.addr = 18446744073709545941LLU; // 99999998lU'''''''''''''''
	98035	+ state.addr = 18446744073709545949LLU; // 99999998lb'''''''''''''''
98258	98036	break;
98259	98037	}
98260		- case 18446744073709545941LLU: // 99999998lU'''''''''''''''
	98038	+ case 18446744073709545949LLU: // 99999998lb'''''''''''''''
98261	98039	{
98262	98040	{
98263	98041	uint64_t arg = 0LLU;

		@@ -98271,7 +98049,7 @@
98271	98049	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98272	98050	}
98273	98051	// 1LLU
98274		- uint64_t return_to = 18446744073709545935LLU;
	98052	+ uint64_t return_to = 18446744073709545943LLU;
98275	98053	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98276	98054	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98277	98055	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98280,12 +98058,12 @@
98280	98058	state.addr = 839519719621918720LLU; // skipws____
98281	98059	break;
98282	98060	}
98283		- case 18446744073709545935LLU: // 99999998lO'''''''''''''''
	98061	+ case 18446744073709545943LLU: // 99999998lW'''''''''''''''
98284	98062	{
98285		- state.addr = 18446744073709545936LLU; // 99999998lP'''''''''''''''
	98063	+ state.addr = 18446744073709545944LLU; // 99999998lX'''''''''''''''
98286	98064	break;
98287	98065	}
98288		- case 18446744073709545936LLU: // 99999998lP'''''''''''''''
	98066	+ case 18446744073709545944LLU: // 99999998lX'''''''''''''''
98289	98067	{
98290	98068	{
98291	98069	uint64_t arg = 0LLU;

		@@ -98300,7 +98078,7 @@
98300	98078	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98301	98079	}
98302	98080	// 1LLU
98303		- uint64_t return_to = 18446744073709545933LLU;
	98081	+ uint64_t return_to = 18446744073709545941LLU;
98304	98082	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98305	98083	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98306	98084	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98309,12 +98087,12 @@
98309	98087	state.addr = 839519719621918720LLU; // skipws____
98310	98088	break;
98311	98089	}
98312		- case 18446744073709545933LLU: // 99999998lM'''''''''''''''
	98090	+ case 18446744073709545941LLU: // 99999998lU'''''''''''''''
98313	98091	{
98314		- state.addr = 18446744073709545934LLU; // 99999998lN'''''''''''''''
	98092	+ state.addr = 18446744073709545942LLU; // 99999998lV'''''''''''''''
98315	98093	break;
98316	98094	}
98317		- case 18446744073709545934LLU: // 99999998lN'''''''''''''''
	98095	+ case 18446744073709545942LLU: // 99999998lV'''''''''''''''
98318	98096	{
98319	98097	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 13LLU, 5LLU)));
98320	98098	{

		@@ -98325,15 +98103,15 @@
98325	98103	uint64_t arg = 0LLU;
98326	98104	LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/address of current closure/, &arg);
98327	98105	}
98328		- state.addr = 18446744073709545932LLU; // 99999998lL'''''''''''''''
	98106	+ state.addr = 18446744073709545940LLU; // 99999998lT'''''''''''''''
98329	98107	break;
98330	98108	}
98331		- case 18446744073709545932LLU: // 99999998lL'''''''''''''''
	98109	+ case 18446744073709545940LLU: // 99999998lT'''''''''''''''
98332	98110	{
98333	98111	access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 5LLU)) = (uint64_t)getchar();
98334	98112	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 5LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 5LLU)) > 255)
98335	98113	{
98336		- state.addr = 18446744073709545931LLU; // 99999998lK'''''''''''''''
	98114	+ state.addr = 18446744073709545939LLU; // 99999998lS'''''''''''''''
98337	98115	break;
98338	98116	}
98339	98117	{

		@@ -98344,7 +98122,7 @@
98344	98122	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98345	98123	}
98346	98124	// 1LLU
98347		- uint64_t return_to = 18446744073709545929LLU;
	98125	+ uint64_t return_to = 18446744073709545937LLU;
98348	98126	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98349	98127	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98350	98128	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98353,19 +98131,19 @@
98353	98131	state.addr = 839519719621918720LLU; // skipws____
98354	98132	break;
98355	98133	}
98356		- case 18446744073709545929LLU: // 99999998lI'''''''''''''''
	98134	+ case 18446744073709545937LLU: // 99999998lQ'''''''''''''''
98357	98135	{
98358		- state.addr = 18446744073709545930LLU; // 99999998lJ'''''''''''''''
	98136	+ state.addr = 18446744073709545938LLU; // 99999998lR'''''''''''''''
98359	98137	break;
98360	98138	}
98361		- case 18446744073709545930LLU: // 99999998lJ'''''''''''''''
	98139	+ case 18446744073709545938LLU: // 99999998lR'''''''''''''''
98362	98140	{
98363	98141	/id________/LOCAL_ACCESS(heap.data, 15LLU, 7LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 5LLU)));
98364	98142	/result____/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = /union_id__/LOCAL_ACCESS(heap.data, 15LLU, 10LLU) == /id________/*LOCAL_ACCESS(heap.data, 15LLU, 7LLU);
98365		- state.addr = /result____/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) ? 18446744073709545928LLU : 18446744073709545927LLU;
	98143	+ state.addr = /result____/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) ? 18446744073709545936LLU : 18446744073709545935LLU;
98366	98144	break;
98367	98145	}
98368		- case 18446744073709545928LLU: // 99999998lH'''''''''''''''
	98146	+ case 18446744073709545936LLU: // 99999998lP'''''''''''''''
98369	98147	{
98370	98148	fprintf(stderr, "%s", "re-definition of union-type ");
98371	98149	printid(stderr, /union_id__/*LOCAL_ACCESS(heap.data, 15LLU, 10LLU));

		@@ -98375,10 +98153,10 @@
98375	98153	fprintf(stderr, "%s\n", "");
98376	98154	exit(-1);
98377	98155	}
98378		- state.addr = 18446744073709545927LLU; // 99999998lG'''''''''''''''
	98156	+ state.addr = 18446744073709545935LLU; // 99999998lO'''''''''''''''
98379	98157	break;
98380	98158	}
98381		- case 18446744073709545927LLU: // 99999998lG'''''''''''''''
	98159	+ case 18446744073709545935LLU: // 99999998lO'''''''''''''''
98382	98160	{
98383	98161	{
98384	98162	uint64_t arg = 0LLU;

		@@ -98400,7 +98178,7 @@
98400	98178	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98401	98179	}
98402	98180	// 3LLU
98403		- uint64_t return_to = 18446744073709545924LLU;
	98181	+ uint64_t return_to = 18446744073709545932LLU;
98404	98182	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98405	98183	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98406	98184	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98409,17 +98187,17 @@
98409	98187	state.addr = 590977518136150752LLU; // existstype
98410	98188	break;
98411	98189	}
98412		- case 18446744073709545924LLU: // 99999998lD'''''''''''''''
	98190	+ case 18446744073709545932LLU: // 99999998lL'''''''''''''''
98413	98191	{
98414		- state.addr = 18446744073709545925LLU; // 99999998lE'''''''''''''''
	98192	+ state.addr = 18446744073709545933LLU; // 99999998lM'''''''''''''''
98415	98193	break;
98416	98194	}
98417		- case 18446744073709545925LLU: // 99999998lE'''''''''''''''
	98195	+ case 18446744073709545933LLU: // 99999998lM'''''''''''''''
98418	98196	{
98419		- state.addr = /exists____/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709545923LLU : 18446744073709545922LLU;
	98197	+ state.addr = /exists____/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709545931LLU : 18446744073709545930LLU;
98420	98198	break;
98421	98199	}
98422		- case 18446744073709545923LLU: // 99999998lC'''''''''''''''
	98200	+ case 18446744073709545931LLU: // 99999998lK'''''''''''''''
98423	98201	{
98424	98202	fprintf(stderr, "%s", "re-definition of union ");
98425	98203	printid(stderr, /union_id__/*LOCAL_ACCESS(heap.data, 16LLU, 10LLU));

		@@ -98429,27 +98207,27 @@
98429	98207	fprintf(stderr, "%s\n", "");
98430	98208	exit(-1);
98431	98209	}
98432		- state.addr = 18446744073709545922LLU; // 99999998lB'''''''''''''''
	98210	+ state.addr = 18446744073709545930LLU; // 99999998lJ'''''''''''''''
98433	98211	break;
98434	98212	}
98435		- case 18446744073709545922LLU: // 99999998lB'''''''''''''''
	98213	+ case 18446744073709545930LLU: // 99999998lJ'''''''''''''''
98436	98214	{
98437	98215	// variable u64 exists____ goes out of scope
98438	98216	// emitted destructur for type u64
98439	98217	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference exists____ at 16
98440		- state.addr = 18446744073709545926LLU; // 99999998lF'''''''''''''''
	98218	+ state.addr = 18446744073709545934LLU; // 99999998lN'''''''''''''''
98441	98219	break;
98442	98220	}
98443		- case 18446744073709545926LLU: // 99999998lF'''''''''''''''
	98221	+ case 18446744073709545934LLU: // 99999998lN'''''''''''''''
98444	98222	{
98445	98223	{
98446	98224	uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 15LLU, 7LLU);
98447	98225	LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/address of current closure/, &arg);
98448	98226	}
98449		- state.addr = !list_push_move(&heap, &/tmp_______/LOCAL_ACCESS(heap.data, 16LLU, 15LLU), &/constrs___/LOCAL_ACCESS(heap.data, 16LLU, 11LLU), 1) ? 18446744073709545920LLU : 18446744073709545919LLU;
	98227	+ state.addr = !list_push_move(&heap, &/tmp_______/LOCAL_ACCESS(heap.data, 16LLU, 15LLU), &/constrs___/LOCAL_ACCESS(heap.data, 16LLU, 11LLU), 1) ? 18446744073709545928LLU : 18446744073709545927LLU;
98450	98228	break;
98451	98229	}
98452		- case 18446744073709545920LLU: // 99999998l_'''''''''''''''
	98230	+ case 18446744073709545928LLU: // 99999998lH'''''''''''''''
98453	98231	{
98454	98232	{
98455	98233	uint64_t arg = *LOCAL_ACCESS(heap.data, 16LLU, 15LLU);

		@@ -98467,23 +98245,23 @@
98467	98245	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp_______ at 17
98468	98246	heap.availilable_size_for_dynamic_objects += 0LLU;
98469	98247	heap.availilable_size_for_dynamic_objects += 0LLU;
98470		- state.addr = 18446744073709545918LLU; // 99999998k8'''''''''''''''
	98248	+ state.addr = 18446744073709545926LLU; // 99999998lF'''''''''''''''
98471	98249	break;
98472	98250	}
98473		- case 18446744073709545919LLU: // 99999998k9'''''''''''''''
	98251	+ case 18446744073709545927LLU: // 99999998lG'''''''''''''''
98474	98252	{
98475		- state.addr = 18446744073709545918LLU; // 99999998k8'''''''''''''''
	98253	+ state.addr = 18446744073709545926LLU; // 99999998lF'''''''''''''''
98476	98254	break;
98477	98255	}
98478		- case 18446744073709545918LLU: // 99999998k8'''''''''''''''
	98256	+ case 18446744073709545926LLU: // 99999998lF'''''''''''''''
98479	98257	{
98480	98258	// variable u64 tmp_______ goes out of scope
98481	98259	// (uninitialized -> no destructor-call)
98482	98260	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp_______ at 16
98483		- state.addr = 18446744073709545921LLU; // 99999998lA'''''''''''''''
	98261	+ state.addr = 18446744073709545929LLU; // 99999998lI'''''''''''''''
98484	98262	break;
98485	98263	}
98486		- case 18446744073709545921LLU: // 99999998lA'''''''''''''''
	98264	+ case 18446744073709545929LLU: // 99999998lI'''''''''''''''
98487	98265	{
98488	98266	{
98489	98267	uint64_t arg = 0LLU;

		@@ -98497,7 +98275,7 @@
98497	98275	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98498	98276	}
98499	98277	// 1LLU
98500		- uint64_t return_to = 18446744073709545915LLU;
	98278	+ uint64_t return_to = 18446744073709545923LLU;
98501	98279	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98502	98280	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98503	98281	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98506,12 +98284,12 @@
98506	98284	state.addr = 839519719621918720LLU; // skipws____
98507	98285	break;
98508	98286	}
98509		- case 18446744073709545915LLU: // 99999998k5'''''''''''''''
	98287	+ case 18446744073709545923LLU: // 99999998lC'''''''''''''''
98510	98288	{
98511		- state.addr = 18446744073709545916LLU; // 99999998k6'''''''''''''''
	98289	+ state.addr = 18446744073709545924LLU; // 99999998lD'''''''''''''''
98512	98290	break;
98513	98291	}
98514		- case 18446744073709545916LLU: // 99999998k6'''''''''''''''
	98292	+ case 18446744073709545924LLU: // 99999998lD'''''''''''''''
98515	98293	{
98516	98294	{
98517	98295	uint64_t mainresult = heap.data[0].elem0;

		@@ -98533,7 +98311,7 @@
98533	98311	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98534	98312	}
98535	98313	// 4LLU
98536		- uint64_t return_to = 18446744073709545913LLU;
	98314	+ uint64_t return_to = 18446744073709545921LLU;
98537	98315	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98538	98316	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98539	98317	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98542,17 +98320,17 @@
98542	98320	state.addr = 782701543351519790LLU; // parseelems
98543	98321	break;
98544	98322	}
98545		- case 18446744073709545913LLU: // 99999998k3'''''''''''''''
	98323	+ case 18446744073709545921LLU: // 99999998lA'''''''''''''''
98546	98324	{
98547		- state.addr = 18446744073709545914LLU; // 99999998k4'''''''''''''''
	98325	+ state.addr = 18446744073709545922LLU; // 99999998lB'''''''''''''''
98548	98326	break;
98549	98327	}
98550		- case 18446744073709545914LLU: // 99999998k4'''''''''''''''
	98328	+ case 18446744073709545922LLU: // 99999998lB'''''''''''''''
98551	98329	{
98552		- state.addr = 18446744073709545917LLU; // 99999998k7'''''''''''''''
	98330	+ state.addr = 18446744073709545925LLU; // 99999998lE'''''''''''''''
98553	98331	break;
98554	98332	}
98555		- case 18446744073709545917LLU: // 99999998k7'''''''''''''''
	98333	+ case 18446744073709545925LLU: // 99999998lE'''''''''''''''
98556	98334	{
98557	98335	{
98558	98336	uint64_t arg = 0LLU;

		@@ -98578,7 +98356,7 @@
98578	98356	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98579	98357	}
98580	98358	// 2LLU
98581		- uint64_t return_to = 18446744073709545910LLU;
	98359	+ uint64_t return_to = 18446744073709545918LLU;
98582	98360	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98583	98361	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98584	98362	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98587,12 +98365,12 @@
98587	98365	state.addr = 621679233931860255LLU; // gendestrid
98588	98366	break;
98589	98367	}
98590		- case 18446744073709545910LLU: // 99999998k0'''''''''''''''
	98368	+ case 18446744073709545918LLU: // 99999998k8'''''''''''''''
98591	98369	{
98592		- state.addr = 18446744073709545911LLU; // 99999998k1'''''''''''''''
	98370	+ state.addr = 18446744073709545919LLU; // 99999998k9'''''''''''''''
98593	98371	break;
98594	98372	}
98595		- case 18446744073709545911LLU: // 99999998k1'''''''''''''''
	98373	+ case 18446744073709545919LLU: // 99999998k9'''''''''''''''
98596	98374	{
98597	98375	{
98598	98376	uint64_t mainresult = heap.data[0].elem0;

		@@ -98602,7 +98380,7 @@
98602	98380	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98603	98381	}
98604	98382	// 1LLU
98605		- uint64_t return_to = 18446744073709545908LLU;
	98383	+ uint64_t return_to = 18446744073709545916LLU;
98606	98384	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98607	98385	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98608	98386	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98611,12 +98389,12 @@
98611	98389	state.addr = 587881345921715008LLU; // emitenter_
98612	98390	break;
98613	98391	}
98614		- case 18446744073709545908LLU: // 99999998ky'''''''''''''''
	98392	+ case 18446744073709545916LLU: // 99999998k6'''''''''''''''
98615	98393	{
98616		- state.addr = 18446744073709545909LLU; // 99999998kz'''''''''''''''
	98394	+ state.addr = 18446744073709545917LLU; // 99999998k7'''''''''''''''
98617	98395	break;
98618	98396	}
98619		- case 18446744073709545909LLU: // 99999998kz'''''''''''''''
	98397	+ case 18446744073709545917LLU: // 99999998k7'''''''''''''''
98620	98398	{
98621	98399	{
98622	98400	uint64_t arg = 1LLU;

		@@ -98630,7 +98408,7 @@
98630	98408	uint64_t mainresult = heap.data[0].elem0;
98631	98409	heap.data[0].elem0 = 0;
98632	98410	// 0LLU
98633		- uint64_t return_to = 18446744073709545906LLU;
	98411	+ uint64_t return_to = 18446744073709545914LLU;
98634	98412	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98635	98413	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98636	98414	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98639,12 +98417,12 @@
98639	98417	state.addr = 890787671342055424LLU; // varopen___
98640	98418	break;
98641	98419	}
98642		- case 18446744073709545906LLU: // 99999998kw'''''''''''''''
	98420	+ case 18446744073709545914LLU: // 99999998k4'''''''''''''''
98643	98421	{
98644		- state.addr = 18446744073709545907LLU; // 99999998kx'''''''''''''''
	98422	+ state.addr = 18446744073709545915LLU; // 99999998k5'''''''''''''''
98645	98423	break;
98646	98424	}
98647		- case 18446744073709545907LLU: // 99999998kx'''''''''''''''
	98425	+ case 18446744073709545915LLU: // 99999998k5'''''''''''''''
98648	98426	{
98649	98427	fprintf(stdout, "%s", "0");
98650	98428	{

		@@ -98671,7 +98449,7 @@
98671	98449	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98672	98450	}
98673	98451	// 5LLU
98674		- uint64_t return_to = 18446744073709545904LLU;
	98452	+ uint64_t return_to = 18446744073709545912LLU;
98675	98453	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98676	98454	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98677	98455	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98680,12 +98458,12 @@
98680	98458	state.addr = 890786842582581248LLU; // varclose__
98681	98459	break;
98682	98460	}
98683		- case 18446744073709545904LLU: // 99999998ku'''''''''''''''
	98461	+ case 18446744073709545912LLU: // 99999998k2'''''''''''''''
98684	98462	{
98685		- state.addr = 18446744073709545905LLU; // 99999998kv'''''''''''''''
	98463	+ state.addr = 18446744073709545913LLU; // 99999998k3'''''''''''''''
98686	98464	break;
98687	98465	}
98688		- case 18446744073709545905LLU: // 99999998kv'''''''''''''''
	98466	+ case 18446744073709545913LLU: // 99999998k3'''''''''''''''
98689	98467	{
98690	98468	{
98691	98469	uint64_t arg = 0LLU;

		@@ -98700,10 +98478,10 @@
98700	98478	uint64_t arg = 0;
98701	98479	LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/address of current closure/, &arg);
98702	98480	}
98703		- state.addr = 18446744073709545903LLU; // 99999998kt'''''''''''''''
	98481	+ state.addr = 18446744073709545911LLU; // 99999998k1'''''''''''''''
98704	98482	break;
98705	98483	}
98706		- case 18446744073709545903LLU: // 99999998kt'''''''''''''''
	98484	+ case 18446744073709545911LLU: // 99999998k1'''''''''''''''
98707	98485	{
98708	98486	if(!*LOCAL_ACCESS(heap.data, 24LLU, 22LLU))
98709	98487	{

		@@ -98710,7 +98488,7 @@
98710	98488	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 24
98711	98489	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
98712	98490	{
98713		- state.addr = 18446744073709545902LLU; // 99999998ks'''''''''''''''
	98491	+ state.addr = 18446744073709545910LLU; // 99999998k0'''''''''''''''
98714	98492	break;
98715	98493	}
98716	98494	}

		@@ -98741,7 +98519,7 @@
98741	98519	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98742	98520	}
98743	98521	// 4LLU
98744		- uint64_t return_to = 18446744073709545900LLU;
	98522	+ uint64_t return_to = 18446744073709545908LLU;
98745	98523	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98746	98524	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98747	98525	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98750,12 +98528,12 @@
98750	98528	state.addr = 587881363956563968LLU; // emitvar___
98751	98529	break;
98752	98530	}
98753		- case 18446744073709545900LLU: // 99999998kq'''''''''''''''
	98531	+ case 18446744073709545908LLU: // 99999998ky'''''''''''''''
98754	98532	{
98755		- state.addr = 18446744073709545901LLU; // 99999998kr'''''''''''''''
	98533	+ state.addr = 18446744073709545909LLU; // 99999998kz'''''''''''''''
98756	98534	break;
98757	98535	}
98758		- case 18446744073709545901LLU: // 99999998kr'''''''''''''''
	98536	+ case 18446744073709545909LLU: // 99999998kz'''''''''''''''
98759	98537	{
98760	98538	fprintf(stdout, "%s", " = tree_pop_move(&heap, ");
98761	98539	{

		@@ -98766,7 +98544,7 @@
98766	98544	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98767	98545	}
98768	98546	// 1LLU
98769		- uint64_t return_to = 18446744073709545898LLU;
	98547	+ uint64_t return_to = 18446744073709545906LLU;
98770	98548	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98771	98549	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98772	98550	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98775,12 +98553,12 @@
98775	98553	state.addr = 787446708198178816LLU; // printnr___
98776	98554	break;
98777	98555	}
98778		- case 18446744073709545898LLU: // 99999998ko'''''''''''''''
	98556	+ case 18446744073709545906LLU: // 99999998kw'''''''''''''''
98779	98557	{
98780		- state.addr = 18446744073709545899LLU; // 99999998kp'''''''''''''''
	98558	+ state.addr = 18446744073709545907LLU; // 99999998kx'''''''''''''''
98781	98559	break;
98782	98560	}
98783		- case 18446744073709545899LLU: // 99999998kp'''''''''''''''
	98561	+ case 18446744073709545907LLU: // 99999998kx'''''''''''''''
98784	98562	{
98785	98563	fprintf(stdout, "%s", ", &");
98786	98564	{

		@@ -98803,7 +98581,7 @@
98803	98581	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98804	98582	}
98805	98583	// 4LLU
98806		- uint64_t return_to = 18446744073709545896LLU;
	98584	+ uint64_t return_to = 18446744073709545904LLU;
98807	98585	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98808	98586	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98809	98587	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98812,12 +98590,12 @@
98812	98590	state.addr = 587881359725559808LLU; // emitref___
98813	98591	break;
98814	98592	}
98815		- case 18446744073709545896LLU: // 99999998km'''''''''''''''
	98593	+ case 18446744073709545904LLU: // 99999998ku'''''''''''''''
98816	98594	{
98817		- state.addr = 18446744073709545897LLU; // 99999998kn'''''''''''''''
	98595	+ state.addr = 18446744073709545905LLU; // 99999998kv'''''''''''''''
98818	98596	break;
98819	98597	}
98820		- case 18446744073709545897LLU: // 99999998kn'''''''''''''''
	98598	+ case 18446744073709545905LLU: // 99999998kv'''''''''''''''
98821	98599	{
98822	98600	fprintf(stdout, "%s", ");\n");
98823	98601	{

		@@ -98860,7 +98638,7 @@
98860	98638	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98861	98639	}
98862	98640	// 9LLU
98863		- uint64_t return_to = 18446744073709545894LLU;
	98641	+ uint64_t return_to = 18446744073709545902LLU;
98864	98642	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98865	98643	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98866	98644	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98869,12 +98647,12 @@
98869	98647	state.addr = 587881344696777536LLU; // emitdestr_
98870	98648	break;
98871	98649	}
98872		- case 18446744073709545894LLU: // 99999998kk'''''''''''''''
	98650	+ case 18446744073709545902LLU: // 99999998ks'''''''''''''''
98873	98651	{
98874		- state.addr = 18446744073709545895LLU; // 99999998kl'''''''''''''''
	98652	+ state.addr = 18446744073709545903LLU; // 99999998kt'''''''''''''''
98875	98653	break;
98876	98654	}
98877		- case 18446744073709545895LLU: // 99999998kl'''''''''''''''
	98655	+ case 18446744073709545903LLU: // 99999998kt'''''''''''''''
98878	98656	{
98879	98657	{
98880	98658	uint64_t arg = 0LLU;

		@@ -98896,7 +98674,7 @@
98896	98674	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98897	98675	}
98898	98676	// 2LLU
98899		- uint64_t return_to = 18446744073709545892LLU;
	98677	+ uint64_t return_to = 18446744073709545900LLU;
98900	98678	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98901	98679	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98902	98680	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98905,12 +98683,12 @@
98905	98683	state.addr = 861504787186880512LLU; // typemain__
98906	98684	break;
98907	98685	}
98908		- case 18446744073709545892LLU: // 99999998ki'''''''''''''''
	98686	+ case 18446744073709545900LLU: // 99999998kq'''''''''''''''
98909	98687	{
98910		- state.addr = 18446744073709545893LLU; // 99999998kj'''''''''''''''
	98688	+ state.addr = 18446744073709545901LLU; // 99999998kr'''''''''''''''
98911	98689	break;
98912	98690	}
98913		- case 18446744073709545893LLU: // 99999998kj'''''''''''''''
	98691	+ case 18446744073709545901LLU: // 99999998kr'''''''''''''''
98914	98692	{
98915	98693	{
98916	98694	uint64_t mainresult = heap.data[0].elem0;

		@@ -98932,7 +98710,7 @@
98932	98710	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98933	98711	}
98934	98712	// 4LLU
98935		- uint64_t return_to = 18446744073709545890LLU;
	98713	+ uint64_t return_to = 18446744073709545898LLU;
98936	98714	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98937	98715	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98938	98716	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -98941,12 +98719,12 @@
98941	98719	state.addr = 861504789552170795LLU; // typeonheap
98942	98720	break;
98943	98721	}
98944		- case 18446744073709545890LLU: // 99999998kg'''''''''''''''
	98722	+ case 18446744073709545898LLU: // 99999998ko'''''''''''''''
98945	98723	{
98946		- state.addr = 18446744073709545891LLU; // 99999998kh'''''''''''''''
	98724	+ state.addr = 18446744073709545899LLU; // 99999998kp'''''''''''''''
98947	98725	break;
98948	98726	}
98949		- case 18446744073709545891LLU: // 99999998kh'''''''''''''''
	98727	+ case 18446744073709545899LLU: // 99999998kp'''''''''''''''
98950	98728	{
98951	98729	/sumheapsz_/LOCAL_ACCESS(heap.data, 27LLU, 16LLU) = /sumheapsz_/LOCAL_ACCESS(heap.data, 27LLU, 16LLU) + /reqsize___/*LOCAL_ACCESS(heap.data, 27LLU, 25LLU);
98952	98730	++/sumheapsz_/*LOCAL_ACCESS(heap.data, 27LLU, 16LLU);

		@@ -98962,10 +98740,10 @@
98962	98740	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx____ at 25
98963	98741	// parameter-reference elemdef___ elemtype__ goes out of scope
98964	98742	// parameter list<elemdef___> defpars___ goes out of scope
98965		- state.addr = 18446744073709545903LLU; // 99999998kt'''''''''''''''
	98743	+ state.addr = 18446744073709545911LLU; // 99999998k1'''''''''''''''
98966	98744	break;
98967	98745	}
98968		- case 18446744073709545902LLU: // 99999998ks'''''''''''''''
	98746	+ case 18446744073709545910LLU: // 99999998k0'''''''''''''''
98969	98747	{
98970	98748	fprintf(stdout, "%s", "\n // RELEASE temporary destructor-variable");
98971	98749	{

		@@ -98992,7 +98770,7 @@
98992	98770	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
98993	98771	}
98994	98772	// 4LLU
98995		- uint64_t return_to = 18446744073709545887LLU;
	98773	+ uint64_t return_to = 18446744073709545895LLU;
98996	98774	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
98997	98775	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
98998	98776	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99001,20 +98779,20 @@
99001	98779	state.addr = 587881357748664875LLU; // emitpoptmp
99002	98780	break;
99003	98781	}
99004		- case 18446744073709545887LLU: // 99999998kd'''''''''''''''
	98782	+ case 18446744073709545895LLU: // 99999998kl'''''''''''''''
99005	98783	{
99006		- state.addr = 18446744073709545888LLU; // 99999998ke'''''''''''''''
	98784	+ state.addr = 18446744073709545896LLU; // 99999998km'''''''''''''''
99007	98785	break;
99008	98786	}
99009		- case 18446744073709545888LLU: // 99999998ke'''''''''''''''
	98787	+ case 18446744073709545896LLU: // 99999998km'''''''''''''''
99010	98788	{
99011	98789	// variable u64 level_____ goes out of scope
99012	98790	// emitted destructur for type u64
99013	98791	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 23
99014		- state.addr = 18446744073709545889LLU; // 99999998kf'''''''''''''''
	98792	+ state.addr = 18446744073709545897LLU; // 99999998kn'''''''''''''''
99015	98793	break;
99016	98794	}
99017		- case 18446744073709545889LLU: // 99999998kf'''''''''''''''
	98795	+ case 18446744073709545897LLU: // 99999998kn'''''''''''''''
99018	98796	{
99019	98797	fprintf(stdout, "%s", "\n // RELEASE destructor-argument");
99020	98798	{

		@@ -99041,7 +98819,7 @@
99041	98819	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99042	98820	}
99043	98821	// 4LLU
99044		- uint64_t return_to = 18446744073709545884LLU;
	98822	+ uint64_t return_to = 18446744073709545892LLU;
99045	98823	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99046	98824	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99047	98825	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99050,20 +98828,20 @@
99050	98828	state.addr = 587881357748664875LLU; // emitpoptmp
99051	98829	break;
99052	98830	}
99053		- case 18446744073709545884LLU: // 99999998ka'''''''''''''''
	98831	+ case 18446744073709545892LLU: // 99999998ki'''''''''''''''
99054	98832	{
99055		- state.addr = 18446744073709545885LLU; // 99999998kb'''''''''''''''
	98833	+ state.addr = 18446744073709545893LLU; // 99999998kj'''''''''''''''
99056	98834	break;
99057	98835	}
99058		- case 18446744073709545885LLU: // 99999998kb'''''''''''''''
	98836	+ case 18446744073709545893LLU: // 99999998kj'''''''''''''''
99059	98837	{
99060	98838	// variable u64 level_____ goes out of scope
99061	98839	// emitted destructur for type u64
99062	98840	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 23
99063		- state.addr = 18446744073709545886LLU; // 99999998kc'''''''''''''''
	98841	+ state.addr = 18446744073709545894LLU; // 99999998kk'''''''''''''''
99064	98842	break;
99065	98843	}
99066		- case 18446744073709545886LLU: // 99999998kc'''''''''''''''
	98844	+ case 18446744073709545894LLU: // 99999998kk'''''''''''''''
99067	98845	{
99068	98846	{
99069	98847	uint64_t mainresult = heap.data[0].elem0;

		@@ -99081,7 +98859,7 @@
99081	98859	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99082	98860	}
99083	98861	// 3LLU
99084		- uint64_t return_to = 18446744073709545882LLU;
	98862	+ uint64_t return_to = 18446744073709545890LLU;
99085	98863	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99086	98864	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99087	98865	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99090,12 +98868,12 @@
99090	98868	state.addr = 587881353282000896LLU; // emitleave_
99091	98869	break;
99092	98870	}
99093		- case 18446744073709545882LLU: // 99999998kZ'''''''''''''''
	98871	+ case 18446744073709545890LLU: // 99999998kg'''''''''''''''
99094	98872	{
99095		- state.addr = 18446744073709545883LLU; // 99999998k$'''''''''''''''
	98873	+ state.addr = 18446744073709545891LLU; // 99999998kh'''''''''''''''
99096	98874	break;
99097	98875	}
99098		- case 18446744073709545883LLU: // 99999998k$'''''''''''''''
	98876	+ case 18446744073709545891LLU: // 99999998kh'''''''''''''''
99099	98877	{
99100	98878	/maxheapsz_/LOCAL_ACCESS(heap.data, 22LLU, 13LLU) = max(/maxheapsz_/LOCAL_ACCESS(heap.data, 22LLU, 13LLU), /sumheapsz_/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU));
99101	98879	// variable u64 elemcount_ goes out of scope

		@@ -99113,10 +98891,10 @@
99113	98891	// variable u64 remainsize goes out of scope
99114	98892	// emitted destructur for type u64
99115	98893	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 18
99116		- state.addr = 18446744073709545912LLU; // 99999998k2'''''''''''''''
	98894	+ state.addr = 18446744073709545920LLU; // 99999998l_'''''''''''''''
99117	98895	break;
99118	98896	}
99119		- case 18446744073709545912LLU: // 99999998k2'''''''''''''''
	98897	+ case 18446744073709545920LLU: // 99999998l_'''''''''''''''
99120	98898	{
99121	98899	{
99122	98900	uint64_t arg = /sizelimit_/*LOCAL_ACCESS(heap.data, 17LLU, 12LLU);

		@@ -99138,7 +98916,7 @@
99138	98916	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99139	98917	}
99140	98918	// 2LLU
99141		- uint64_t return_to = 18446744073709545879LLU;
	98919	+ uint64_t return_to = 18446744073709545887LLU;
99142	98920	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99143	98921	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99144	98922	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99147,12 +98925,12 @@
99147	98925	state.addr = 621679175848052672LLU; // gencompid_
99148	98926	break;
99149	98927	}
99150		- case 18446744073709545879LLU: // 99999998kW'''''''''''''''
	98928	+ case 18446744073709545887LLU: // 99999998kd'''''''''''''''
99151	98929	{
99152		- state.addr = 18446744073709545880LLU; // 99999998kX'''''''''''''''
	98930	+ state.addr = 18446744073709545888LLU; // 99999998ke'''''''''''''''
99153	98931	break;
99154	98932	}
99155		- case 18446744073709545880LLU: // 99999998kX'''''''''''''''
	98933	+ case 18446744073709545888LLU: // 99999998ke'''''''''''''''
99156	98934	{
99157	98935	{
99158	98936	uint64_t mainresult = heap.data[0].elem0;

		@@ -99162,7 +98940,7 @@
99162	98940	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99163	98941	}
99164	98942	// 1LLU
99165		- uint64_t return_to = 18446744073709545877LLU;
	98943	+ uint64_t return_to = 18446744073709545885LLU;
99166	98944	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99167	98945	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99168	98946	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99171,12 +98949,12 @@
99171	98949	state.addr = 587881345921715008LLU; // emitenter_
99172	98950	break;
99173	98951	}
99174		- case 18446744073709545877LLU: // 99999998kU'''''''''''''''
	98952	+ case 18446744073709545885LLU: // 99999998kb'''''''''''''''
99175	98953	{
99176		- state.addr = 18446744073709545878LLU; // 99999998kV'''''''''''''''
	98954	+ state.addr = 18446744073709545886LLU; // 99999998kc'''''''''''''''
99177	98955	break;
99178	98956	}
99179		- case 18446744073709545878LLU: // 99999998kV'''''''''''''''
	98957	+ case 18446744073709545886LLU: // 99999998kc'''''''''''''''
99180	98958	{
99181	98959	{
99182	98960	uint64_t arg = 3LLU;

		@@ -99194,7 +98972,7 @@
99194	98972	uint64_t mainresult = heap.data[0].elem0;
99195	98973	heap.data[0].elem0 = 0;
99196	98974	// 0LLU
99197		- uint64_t return_to = 18446744073709545875LLU;
	98975	+ uint64_t return_to = 18446744073709545883LLU;
99198	98976	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99199	98977	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99200	98978	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99203,12 +98981,12 @@
99203	98981	state.addr = 890787671342055424LLU; // varopen___
99204	98982	break;
99205	98983	}
99206		- case 18446744073709545875LLU: // 99999998kS'''''''''''''''
	98984	+ case 18446744073709545883LLU: // 99999998k$'''''''''''''''
99207	98985	{
99208		- state.addr = 18446744073709545876LLU; // 99999998kT'''''''''''''''
	98986	+ state.addr = 18446744073709545884LLU; // 99999998ka'''''''''''''''
99209	98987	break;
99210	98988	}
99211		- case 18446744073709545876LLU: // 99999998kT'''''''''''''''
	98989	+ case 18446744073709545884LLU: // 99999998ka'''''''''''''''
99212	98990	{
99213	98991	fprintf(stdout, "%s", "0");
99214	98992	{

		@@ -99235,7 +99013,7 @@
99235	99013	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99236	99014	}
99237	99015	// 5LLU
99238		- uint64_t return_to = 18446744073709545873LLU;
	99016	+ uint64_t return_to = 18446744073709545881LLU;
99239	99017	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99240	99018	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99241	99019	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99244,12 +99022,12 @@
99244	99022	state.addr = 890786842582581248LLU; // varclose__
99245	99023	break;
99246	99024	}
99247		- case 18446744073709545873LLU: // 99999998kQ'''''''''''''''
	99025	+ case 18446744073709545881LLU: // 99999998kY'''''''''''''''
99248	99026	{
99249		- state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
	99027	+ state.addr = 18446744073709545882LLU; // 99999998kZ'''''''''''''''
99250	99028	break;
99251	99029	}
99252		- case 18446744073709545874LLU: // 99999998kR'''''''''''''''
	99030	+ case 18446744073709545882LLU: // 99999998kZ'''''''''''''''
99253	99031	{
99254	99032	{
99255	99033	uint64_t arg = 0LLU;

		@@ -99259,7 +99037,7 @@
99259	99037	uint64_t mainresult = heap.data[0].elem0;
99260	99038	heap.data[0].elem0 = 0;
99261	99039	// 0LLU
99262		- uint64_t return_to = 18446744073709545871LLU;
	99040	+ uint64_t return_to = 18446744073709545879LLU;
99263	99041	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99264	99042	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99265	99043	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99268,12 +99046,12 @@
99268	99046	state.addr = 890787671342055424LLU; // varopen___
99269	99047	break;
99270	99048	}
99271		- case 18446744073709545871LLU: // 99999998kO'''''''''''''''
	99049	+ case 18446744073709545879LLU: // 99999998kW'''''''''''''''
99272	99050	{
99273		- state.addr = 18446744073709545872LLU; // 99999998kP'''''''''''''''
	99051	+ state.addr = 18446744073709545880LLU; // 99999998kX'''''''''''''''
99274	99052	break;
99275	99053	}
99276		- case 18446744073709545872LLU: // 99999998kP'''''''''''''''
	99054	+ case 18446744073709545880LLU: // 99999998kX'''''''''''''''
99277	99055	{
99278	99056	fprintf(stdout, "%s", "0");
99279	99057	{

		@@ -99300,7 +99078,7 @@
99300	99078	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99301	99079	}
99302	99080	// 5LLU
99303		- uint64_t return_to = 18446744073709545869LLU;
	99081	+ uint64_t return_to = 18446744073709545877LLU;
99304	99082	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99305	99083	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99306	99084	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99309,12 +99087,12 @@
99309	99087	state.addr = 890786842582581248LLU; // varclose__
99310	99088	break;
99311	99089	}
99312		- case 18446744073709545869LLU: // 99999998kM'''''''''''''''
	99090	+ case 18446744073709545877LLU: // 99999998kU'''''''''''''''
99313	99091	{
99314		- state.addr = 18446744073709545870LLU; // 99999998kN'''''''''''''''
	99092	+ state.addr = 18446744073709545878LLU; // 99999998kV'''''''''''''''
99315	99093	break;
99316	99094	}
99317		- case 18446744073709545870LLU: // 99999998kN'''''''''''''''
	99095	+ case 18446744073709545878LLU: // 99999998kV'''''''''''''''
99318	99096	{
99319	99097	{
99320	99098	uint64_t arg = 0LLU;

		@@ -99341,7 +99119,7 @@
99341	99119	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99342	99120	}
99343	99121	// 2LLU
99344		- uint64_t return_to = 18446744073709545867LLU;
	99122	+ uint64_t return_to = 18446744073709545875LLU;
99345	99123	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99346	99124	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99347	99125	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99350,12 +99128,12 @@
99350	99128	state.addr = 517555828430075934LLU; // assign_dec
99351	99129	break;
99352	99130	}
99353		- case 18446744073709545867LLU: // 99999998kK'''''''''''''''
	99131	+ case 18446744073709545875LLU: // 99999998kS'''''''''''''''
99354	99132	{
99355		- state.addr = 18446744073709545868LLU; // 99999998kL'''''''''''''''
	99133	+ state.addr = 18446744073709545876LLU; // 99999998kT'''''''''''''''
99356	99134	break;
99357	99135	}
99358		- case 18446744073709545868LLU: // 99999998kL'''''''''''''''
	99136	+ case 18446744073709545876LLU: // 99999998kT'''''''''''''''
99359	99137	{
99360	99138	{
99361	99139	uint64_t arg = /defpars___/*LOCAL_ACCESS(heap.data, 26LLU, 15LLU);

		@@ -99365,10 +99143,10 @@
99365	99143	uint64_t arg = 0;
99366	99144	LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
99367	99145	}
99368		- state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
	99146	+ state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
99369	99147	break;
99370	99148	}
99371		- case 18446744073709545866LLU: // 99999998kJ'''''''''''''''
	99149	+ case 18446744073709545874LLU: // 99999998kR'''''''''''''''
99372	99150	{
99373	99151	if(!*LOCAL_ACCESS(heap.data, 28LLU, 26LLU))
99374	99152	{

		@@ -99375,7 +99153,7 @@
99375	99153	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 28
99376	99154	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
99377	99155	{
99378		- state.addr = 18446744073709545865LLU; // 99999998kI'''''''''''''''
	99156	+ state.addr = 18446744073709545873LLU; // 99999998kQ'''''''''''''''
99379	99157	break;
99380	99158	}
99381	99159	}

		@@ -99406,7 +99184,7 @@
99406	99184	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99407	99185	}
99408	99186	// 4LLU
99409		- uint64_t return_to = 18446744073709545863LLU;
	99187	+ uint64_t return_to = 18446744073709545871LLU;
99410	99188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99411	99189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99412	99190	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99415,12 +99193,12 @@
99415	99193	state.addr = 587881363956563968LLU; // emitvar___
99416	99194	break;
99417	99195	}
99418		- case 18446744073709545863LLU: // 99999998kG'''''''''''''''
	99196	+ case 18446744073709545871LLU: // 99999998kO'''''''''''''''
99419	99197	{
99420		- state.addr = 18446744073709545864LLU; // 99999998kH'''''''''''''''
	99198	+ state.addr = 18446744073709545872LLU; // 99999998kP'''''''''''''''
99421	99199	break;
99422	99200	}
99423		- case 18446744073709545864LLU: // 99999998kH'''''''''''''''
	99201	+ case 18446744073709545872LLU: // 99999998kP'''''''''''''''
99424	99202	{
99425	99203	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, ");
99426	99204	{

		@@ -99431,7 +99209,7 @@
99431	99209	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99432	99210	}
99433	99211	// 1LLU
99434		- uint64_t return_to = 18446744073709545861LLU;
	99212	+ uint64_t return_to = 18446744073709545869LLU;
99435	99213	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99436	99214	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99437	99215	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99440,12 +99218,12 @@
99440	99218	state.addr = 787446708198178816LLU; // printnr___
99441	99219	break;
99442	99220	}
99443		- case 18446744073709545861LLU: // 99999998kE'''''''''''''''
	99221	+ case 18446744073709545869LLU: // 99999998kM'''''''''''''''
99444	99222	{
99445		- state.addr = 18446744073709545862LLU; // 99999998kF'''''''''''''''
	99223	+ state.addr = 18446744073709545870LLU; // 99999998kN'''''''''''''''
99446	99224	break;
99447	99225	}
99448		- case 18446744073709545862LLU: // 99999998kF'''''''''''''''
	99226	+ case 18446744073709545870LLU: // 99999998kN'''''''''''''''
99449	99227	{
99450	99228	fprintf(stdout, "%s", ", ");
99451	99229	{

		@@ -99468,7 +99246,7 @@
99468	99246	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99469	99247	}
99470	99248	// 4LLU
99471		- uint64_t return_to = 18446744073709545859LLU;
	99249	+ uint64_t return_to = 18446744073709545867LLU;
99472	99250	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99473	99251	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99474	99252	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99477,12 +99255,12 @@
99477	99255	state.addr = 587881363956563968LLU; // emitvar___
99478	99256	break;
99479	99257	}
99480		- case 18446744073709545859LLU: // 99999998kC'''''''''''''''
	99258	+ case 18446744073709545867LLU: // 99999998kK'''''''''''''''
99481	99259	{
99482		- state.addr = 18446744073709545860LLU; // 99999998kD'''''''''''''''
	99260	+ state.addr = 18446744073709545868LLU; // 99999998kL'''''''''''''''
99483	99261	break;
99484	99262	}
99485		- case 18446744073709545860LLU: // 99999998kD'''''''''''''''
	99263	+ case 18446744073709545868LLU: // 99999998kL'''''''''''''''
99486	99264	{
99487	99265	fprintf(stdout, "%s", ", ");
99488	99266	{

		@@ -99493,7 +99271,7 @@
99493	99271	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99494	99272	}
99495	99273	// 1LLU
99496		- uint64_t return_to = 18446744073709545857LLU;
	99274	+ uint64_t return_to = 18446744073709545865LLU;
99497	99275	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99498	99276	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99499	99277	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99502,12 +99280,12 @@
99502	99280	state.addr = 787446708198178816LLU; // printnr___
99503	99281	break;
99504	99282	}
99505		- case 18446744073709545857LLU: // 99999998kA'''''''''''''''
	99283	+ case 18446744073709545865LLU: // 99999998kI'''''''''''''''
99506	99284	{
99507		- state.addr = 18446744073709545858LLU; // 99999998kB'''''''''''''''
	99285	+ state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
99508	99286	break;
99509	99287	}
99510		- case 18446744073709545858LLU: // 99999998kB'''''''''''''''
	99288	+ case 18446744073709545866LLU: // 99999998kJ'''''''''''''''
99511	99289	{
99512	99290	fprintf(stdout, "%s", ");");
99513	99291	{

		@@ -99535,7 +99313,7 @@
99535	99313	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99536	99314	}
99537	99315	// 4LLU
99538		- uint64_t return_to = 18446744073709545855LLU;
	99316	+ uint64_t return_to = 18446744073709545863LLU;
99539	99317	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99540	99318	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99541	99319	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99544,12 +99322,12 @@
99544	99322	state.addr = 587881363956563968LLU; // emitvar___
99545	99323	break;
99546	99324	}
99547		- case 18446744073709545855LLU: // 99999998j9'''''''''''''''
	99325	+ case 18446744073709545863LLU: // 99999998kG'''''''''''''''
99548	99326	{
99549		- state.addr = 18446744073709545856LLU; // 99999998k_'''''''''''''''
	99327	+ state.addr = 18446744073709545864LLU; // 99999998kH'''''''''''''''
99550	99328	break;
99551	99329	}
99552		- case 18446744073709545856LLU: // 99999998k_'''''''''''''''
	99330	+ case 18446744073709545864LLU: // 99999998kH'''''''''''''''
99553	99331	{
99554	99332	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, ");
99555	99333	{

		@@ -99560,7 +99338,7 @@
99560	99338	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99561	99339	}
99562	99340	// 1LLU
99563		- uint64_t return_to = 18446744073709545853LLU;
	99341	+ uint64_t return_to = 18446744073709545861LLU;
99564	99342	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99565	99343	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99566	99344	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99569,12 +99347,12 @@
99569	99347	state.addr = 787446708198178816LLU; // printnr___
99570	99348	break;
99571	99349	}
99572		- case 18446744073709545853LLU: // 99999998j7'''''''''''''''
	99350	+ case 18446744073709545861LLU: // 99999998kE'''''''''''''''
99573	99351	{
99574		- state.addr = 18446744073709545854LLU; // 99999998j8'''''''''''''''
	99352	+ state.addr = 18446744073709545862LLU; // 99999998kF'''''''''''''''
99575	99353	break;
99576	99354	}
99577		- case 18446744073709545854LLU: // 99999998j8'''''''''''''''
	99355	+ case 18446744073709545862LLU: // 99999998kF'''''''''''''''
99578	99356	{
99579	99357	fprintf(stdout, "%s", ", ");
99580	99358	{

		@@ -99597,7 +99375,7 @@
99597	99375	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99598	99376	}
99599	99377	// 4LLU
99600		- uint64_t return_to = 18446744073709545851LLU;
	99378	+ uint64_t return_to = 18446744073709545859LLU;
99601	99379	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99602	99380	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99603	99381	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99606,12 +99384,12 @@
99606	99384	state.addr = 587881363956563968LLU; // emitvar___
99607	99385	break;
99608	99386	}
99609		- case 18446744073709545851LLU: // 99999998j5'''''''''''''''
	99387	+ case 18446744073709545859LLU: // 99999998kC'''''''''''''''
99610	99388	{
99611		- state.addr = 18446744073709545852LLU; // 99999998j6'''''''''''''''
	99389	+ state.addr = 18446744073709545860LLU; // 99999998kD'''''''''''''''
99612	99390	break;
99613	99391	}
99614		- case 18446744073709545852LLU: // 99999998j6'''''''''''''''
	99392	+ case 18446744073709545860LLU: // 99999998kD'''''''''''''''
99615	99393	{
99616	99394	fprintf(stdout, "%s", ", ");
99617	99395	{

		@@ -99622,7 +99400,7 @@
99622	99400	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99623	99401	}
99624	99402	// 1LLU
99625		- uint64_t return_to = 18446744073709545849LLU;
	99403	+ uint64_t return_to = 18446744073709545857LLU;
99626	99404	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99627	99405	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99628	99406	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99631,12 +99409,12 @@
99631	99409	state.addr = 787446708198178816LLU; // printnr___
99632	99410	break;
99633	99411	}
99634		- case 18446744073709545849LLU: // 99999998j3'''''''''''''''
	99412	+ case 18446744073709545857LLU: // 99999998kA'''''''''''''''
99635	99413	{
99636		- state.addr = 18446744073709545850LLU; // 99999998j4'''''''''''''''
	99414	+ state.addr = 18446744073709545858LLU; // 99999998kB'''''''''''''''
99637	99415	break;
99638	99416	}
99639		- case 18446744073709545850LLU: // 99999998j4'''''''''''''''
	99417	+ case 18446744073709545858LLU: // 99999998kB'''''''''''''''
99640	99418	{
99641	99419	fprintf(stdout, "%s", ");");
99642	99420	{

		@@ -99711,7 +99489,7 @@
99711	99489	LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99712	99490	}
99713	99491	// 14LLU
99714		- uint64_t return_to = 18446744073709545846LLU;
	99492	+ uint64_t return_to = 18446744073709545854LLU;
99715	99493	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99716	99494	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 14LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99717	99495	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99720,12 +99498,12 @@
99720	99498	state.addr = 587881343789215744LLU; // emitcomp__
99721	99499	break;
99722	99500	}
99723		- case 18446744073709545846LLU: // 99999998j0'''''''''''''''
	99501	+ case 18446744073709545854LLU: // 99999998j8'''''''''''''''
99724	99502	{
99725		- state.addr = 18446744073709545847LLU; // 99999998j1'''''''''''''''
	99503	+ state.addr = 18446744073709545855LLU; // 99999998j9'''''''''''''''
99726	99504	break;
99727	99505	}
99728		- case 18446744073709545847LLU: // 99999998j1'''''''''''''''
	99506	+ case 18446744073709545855LLU: // 99999998j9'''''''''''''''
99729	99507	{
99730	99508	// variable u64 indirect2_ goes out of scope
99731	99509	// emitted destructur for type u64

		@@ -99736,10 +99514,10 @@
99736	99514	// variable u64 indirect__ goes out of scope
99737	99515	// emitted destructur for type u64
99738	99516	(void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference indirect__ at 31
99739		- state.addr = 18446744073709545848LLU; // 99999998j2'''''''''''''''
	99517	+ state.addr = 18446744073709545856LLU; // 99999998k_'''''''''''''''
99740	99518	break;
99741	99519	}
99742		- case 18446744073709545848LLU: // 99999998j2'''''''''''''''
	99520	+ case 18446744073709545856LLU: // 99999998k_'''''''''''''''
99743	99521	{
99744	99522	fprintf(stdout, "%s", "\n if(");
99745	99523	{

		@@ -99762,7 +99540,7 @@
99762	99540	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99763	99541	}
99764	99542	// 4LLU
99765		- uint64_t return_to = 18446744073709545844LLU;
	99543	+ uint64_t return_to = 18446744073709545852LLU;
99766	99544	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99767	99545	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99768	99546	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99771,12 +99549,12 @@
99771	99549	state.addr = 587881359725559808LLU; // emitref___
99772	99550	break;
99773	99551	}
99774		- case 18446744073709545844LLU: // 99999998jy'''''''''''''''
	99552	+ case 18446744073709545852LLU: // 99999998j6'''''''''''''''
99775	99553	{
99776		- state.addr = 18446744073709545845LLU; // 99999998jz'''''''''''''''
	99554	+ state.addr = 18446744073709545853LLU; // 99999998j7'''''''''''''''
99777	99555	break;
99778	99556	}
99779		- case 18446744073709545845LLU: // 99999998jz'''''''''''''''
	99557	+ case 18446744073709545853LLU: // 99999998j7'''''''''''''''
99780	99558	{
99781	99559	fprintf(stdout, "%s", "/result/)");
99782	99560	{

		@@ -99795,7 +99573,7 @@
99795	99573	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99796	99574	}
99797	99575	// 2LLU
99798		- uint64_t return_to = 18446744073709545841LLU;
	99576	+ uint64_t return_to = 18446744073709545849LLU;
99799	99577	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99800	99578	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99801	99579	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99804,20 +99582,20 @@
99804	99582	state.addr = 587881351406075392LLU; // emitjump2_
99805	99583	break;
99806	99584	}
99807		- case 18446744073709545841LLU: // 99999998jv'''''''''''''''
	99585	+ case 18446744073709545849LLU: // 99999998j3'''''''''''''''
99808	99586	{
99809		- state.addr = 18446744073709545842LLU; // 99999998jw'''''''''''''''
	99587	+ state.addr = 18446744073709545850LLU; // 99999998j4'''''''''''''''
99810	99588	break;
99811	99589	}
99812		- case 18446744073709545842LLU: // 99999998jw'''''''''''''''
	99590	+ case 18446744073709545850LLU: // 99999998j4'''''''''''''''
99813	99591	{
99814	99592	// variable u64 level_____ goes out of scope
99815	99593	// emitted destructur for type u64
99816	99594	(void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 31
99817		- state.addr = 18446744073709545843LLU; // 99999998jx'''''''''''''''
	99595	+ state.addr = 18446744073709545851LLU; // 99999998j5'''''''''''''''
99818	99596	break;
99819	99597	}
99820		- case 18446744073709545843LLU: // 99999998jx'''''''''''''''
	99598	+ case 18446744073709545851LLU: // 99999998j5'''''''''''''''
99821	99599	{
99822	99600	++/elemnr____/*LOCAL_ACCESS(heap.data, 30LLU, 24LLU);
99823	99601	// variable u64 paridx2___ goes out of scope

		@@ -99828,10 +99606,10 @@
99828	99606	(void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference paridx1___ at 29
99829	99607	// parameter-reference elemdef___ elemtype__ goes out of scope
99830	99608	// parameter list<elemdef___> defpars___ goes out of scope
99831		- state.addr = 18446744073709545866LLU; // 99999998kJ'''''''''''''''
	99609	+ state.addr = 18446744073709545874LLU; // 99999998kR'''''''''''''''
99832	99610	break;
99833	99611	}
99834		- case 18446744073709545865LLU: // 99999998kI'''''''''''''''
	99612	+ case 18446744073709545873LLU: // 99999998kQ'''''''''''''''
99835	99613	{
99836	99614	{
99837	99615	uint64_t arg = 0LLU;

		@@ -99849,7 +99627,7 @@
99849	99627	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99850	99628	}
99851	99629	// 2LLU
99852		- uint64_t return_to = 18446744073709545838LLU;
	99630	+ uint64_t return_to = 18446744073709545846LLU;
99853	99631	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99854	99632	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99855	99633	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99858,20 +99636,20 @@
99858	99636	state.addr = 587881353215084992LLU; // emitlabel_
99859	99637	break;
99860	99638	}
99861		- case 18446744073709545838LLU: // 99999998js'''''''''''''''
	99639	+ case 18446744073709545846LLU: // 99999998j0'''''''''''''''
99862	99640	{
99863		- state.addr = 18446744073709545839LLU; // 99999998jt'''''''''''''''
	99641	+ state.addr = 18446744073709545847LLU; // 99999998j1'''''''''''''''
99864	99642	break;
99865	99643	}
99866		- case 18446744073709545839LLU: // 99999998jt'''''''''''''''
	99644	+ case 18446744073709545847LLU: // 99999998j1'''''''''''''''
99867	99645	{
99868	99646	// variable u64 level_____ goes out of scope
99869	99647	// emitted destructur for type u64
99870	99648	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 27
99871		- state.addr = 18446744073709545840LLU; // 99999998ju'''''''''''''''
	99649	+ state.addr = 18446744073709545848LLU; // 99999998j2'''''''''''''''
99872	99650	break;
99873	99651	}
99874		- case 18446744073709545840LLU: // 99999998ju'''''''''''''''
	99652	+ case 18446744073709545848LLU: // 99999998j2'''''''''''''''
99875	99653	{
99876	99654	fprintf(stdout, "%s", "\n // RELEASE temporary comparator-variables\n");
99877	99655	{

		@@ -99898,7 +99676,7 @@
99898	99676	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99899	99677	}
99900	99678	// 4LLU
99901		- uint64_t return_to = 18446744073709545835LLU;
	99679	+ uint64_t return_to = 18446744073709545843LLU;
99902	99680	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99903	99681	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99904	99682	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99907,12 +99685,12 @@
99907	99685	state.addr = 587881357748664875LLU; // emitpoptmp
99908	99686	break;
99909	99687	}
99910		- case 18446744073709545835LLU: // 99999998jp'''''''''''''''
	99688	+ case 18446744073709545843LLU: // 99999998jx'''''''''''''''
99911	99689	{
99912		- state.addr = 18446744073709545836LLU; // 99999998jq'''''''''''''''
	99690	+ state.addr = 18446744073709545844LLU; // 99999998jy'''''''''''''''
99913	99691	break;
99914	99692	}
99915		- case 18446744073709545836LLU: // 99999998jq'''''''''''''''
	99693	+ case 18446744073709545844LLU: // 99999998jy'''''''''''''''
99916	99694	{
99917	99695	{
99918	99696	uint64_t mainresult = heap.data[0].elem0;

		@@ -99934,7 +99712,7 @@
99934	99712	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99935	99713	}
99936	99714	// 4LLU
99937		- uint64_t return_to = 18446744073709545833LLU;
	99715	+ uint64_t return_to = 18446744073709545841LLU;
99938	99716	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99939	99717	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99940	99718	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99943,20 +99721,20 @@
99943	99721	state.addr = 587881357748664875LLU; // emitpoptmp
99944	99722	break;
99945	99723	}
99946		- case 18446744073709545833LLU: // 99999998jn'''''''''''''''
	99724	+ case 18446744073709545841LLU: // 99999998jv'''''''''''''''
99947	99725	{
99948		- state.addr = 18446744073709545834LLU; // 99999998jo'''''''''''''''
	99726	+ state.addr = 18446744073709545842LLU; // 99999998jw'''''''''''''''
99949	99727	break;
99950	99728	}
99951		- case 18446744073709545834LLU: // 99999998jo'''''''''''''''
	99729	+ case 18446744073709545842LLU: // 99999998jw'''''''''''''''
99952	99730	{
99953	99731	// variable u64 level_____ goes out of scope
99954	99732	// emitted destructur for type u64
99955	99733	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 27
99956		- state.addr = 18446744073709545837LLU; // 99999998jr'''''''''''''''
	99734	+ state.addr = 18446744073709545845LLU; // 99999998jz'''''''''''''''
99957	99735	break;
99958	99736	}
99959		- case 18446744073709545837LLU: // 99999998jr'''''''''''''''
	99737	+ case 18446744073709545845LLU: // 99999998jz'''''''''''''''
99960	99738	{
99961	99739	fprintf(stdout, "%s", "\n // RELEASE comparator-arguments\n");
99962	99740	{

		@@ -99983,7 +99761,7 @@
99983	99761	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
99984	99762	}
99985	99763	// 4LLU
99986		- uint64_t return_to = 18446744073709545830LLU;
	99764	+ uint64_t return_to = 18446744073709545838LLU;
99987	99765	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
99988	99766	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
99989	99767	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -99992,12 +99770,12 @@
99992	99770	state.addr = 587881357748664875LLU; // emitpoptmp
99993	99771	break;
99994	99772	}
99995		- case 18446744073709545830LLU: // 99999998jk'''''''''''''''
	99773	+ case 18446744073709545838LLU: // 99999998js'''''''''''''''
99996	99774	{
99997		- state.addr = 18446744073709545831LLU; // 99999998jl'''''''''''''''
	99775	+ state.addr = 18446744073709545839LLU; // 99999998jt'''''''''''''''
99998	99776	break;
99999	99777	}
100000		- case 18446744073709545831LLU: // 99999998jl'''''''''''''''
	99778	+ case 18446744073709545839LLU: // 99999998jt'''''''''''''''
100001	99779	{
100002	99780	{
100003	99781	uint64_t mainresult = heap.data[0].elem0;

		@@ -100019,7 +99797,7 @@
100019	99797	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100020	99798	}
100021	99799	// 4LLU
100022		- uint64_t return_to = 18446744073709545828LLU;
	99800	+ uint64_t return_to = 18446744073709545836LLU;
100023	99801	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100024	99802	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100025	99803	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100028,12 +99806,12 @@
100028	99806	state.addr = 587881357748664875LLU; // emitpoptmp
100029	99807	break;
100030	99808	}
100031		- case 18446744073709545828LLU: // 99999998ji'''''''''''''''
	99809	+ case 18446744073709545836LLU: // 99999998jq'''''''''''''''
100032	99810	{
100033		- state.addr = 18446744073709545829LLU; // 99999998jj'''''''''''''''
	99811	+ state.addr = 18446744073709545837LLU; // 99999998jr'''''''''''''''
100034	99812	break;
100035	99813	}
100036		- case 18446744073709545829LLU: // 99999998jj'''''''''''''''
	99814	+ case 18446744073709545837LLU: // 99999998jr'''''''''''''''
100037	99815	{
100038	99816	{
100039	99817	uint64_t mainresult = heap.data[0].elem0;

		@@ -100055,7 +99833,7 @@
100055	99833	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100056	99834	}
100057	99835	// 4LLU
100058		- uint64_t return_to = 18446744073709545826LLU;
	99836	+ uint64_t return_to = 18446744073709545834LLU;
100059	99837	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100060	99838	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100061	99839	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100064,20 +99842,20 @@
100064	99842	state.addr = 587881357748664875LLU; // emitpoptmp
100065	99843	break;
100066	99844	}
100067		- case 18446744073709545826LLU: // 99999998jg'''''''''''''''
	99845	+ case 18446744073709545834LLU: // 99999998jo'''''''''''''''
100068	99846	{
100069		- state.addr = 18446744073709545827LLU; // 99999998jh'''''''''''''''
	99847	+ state.addr = 18446744073709545835LLU; // 99999998jp'''''''''''''''
100070	99848	break;
100071	99849	}
100072		- case 18446744073709545827LLU: // 99999998jh'''''''''''''''
	99850	+ case 18446744073709545835LLU: // 99999998jp'''''''''''''''
100073	99851	{
100074	99852	// variable u64 level_____ goes out of scope
100075	99853	// emitted destructur for type u64
100076	99854	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 27
100077		- state.addr = 18446744073709545832LLU; // 99999998jm'''''''''''''''
	99855	+ state.addr = 18446744073709545840LLU; // 99999998ju'''''''''''''''
100078	99856	break;
100079	99857	}
100080		- case 18446744073709545832LLU: // 99999998jm'''''''''''''''
	99858	+ case 18446744073709545840LLU: // 99999998ju'''''''''''''''
100081	99859	{
100082	99860	{
100083	99861	uint64_t mainresult = heap.data[0].elem0;

		@@ -100095,7 +99873,7 @@
100095	99873	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100096	99874	}
100097	99875	// 3LLU
100098		- uint64_t return_to = 18446744073709545824LLU;
	99876	+ uint64_t return_to = 18446744073709545832LLU;
100099	99877	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100100	99878	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100101	99879	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100104,12 +99882,12 @@
100104	99882	state.addr = 587881353282000896LLU; // emitleave_
100105	99883	break;
100106	99884	}
100107		- case 18446744073709545824LLU: // 99999998je'''''''''''''''
	99885	+ case 18446744073709545832LLU: // 99999998jm'''''''''''''''
100108	99886	{
100109		- state.addr = 18446744073709545825LLU; // 99999998jf'''''''''''''''
	99887	+ state.addr = 18446744073709545833LLU; // 99999998jn'''''''''''''''
100110	99888	break;
100111	99889	}
100112		- case 18446744073709545825LLU: // 99999998jf'''''''''''''''
	99890	+ case 18446744073709545833LLU: // 99999998jn'''''''''''''''
100113	99891	{
100114	99892	// variable u64 skiplabel_ goes out of scope
100115	99893	// emitted destructur for type u64

		@@ -100138,10 +99916,10 @@
100138	99916	// variable u64 remainsize goes out of scope
100139	99917	// emitted destructur for type u64
100140	99918	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 18
100141		- state.addr = 18446744073709545881LLU; // 99999998kY'''''''''''''''
	99919	+ state.addr = 18446744073709545889LLU; // 99999998kf'''''''''''''''
100142	99920	break;
100143	99921	}
100144		- case 18446744073709545881LLU: // 99999998kY'''''''''''''''
	99922	+ case 18446744073709545889LLU: // 99999998kf'''''''''''''''
100145	99923	{
100146	99924	{
100147	99925	uint64_t mainresult = heap.data[0].elem0;

		@@ -100167,7 +99945,7 @@
100167	99945	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100168	99946	}
100169	99947	// 5LLU
100170		- uint64_t return_to = 18446744073709545821LLU;
	99948	+ uint64_t return_to = 18446744073709545829LLU;
100171	99949	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100172	99950	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100173	99951	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100176,17 +99954,17 @@
100176	99954	state.addr = 788334702348118622LLU; // pushunionc
100177	99955	break;
100178	99956	}
100179		- case 18446744073709545821LLU: // 99999998jb'''''''''''''''
	99957	+ case 18446744073709545829LLU: // 99999998jj'''''''''''''''
100180	99958	{
100181		- state.addr = 18446744073709545822LLU; // 99999998jc'''''''''''''''
	99959	+ state.addr = 18446744073709545830LLU; // 99999998jk'''''''''''''''
100182	99960	break;
100183	99961	}
100184		- case 18446744073709545822LLU: // 99999998jc'''''''''''''''
	99962	+ case 18446744073709545830LLU: // 99999998jk'''''''''''''''
100185	99963	{
100186		- state.addr = 18446744073709545823LLU; // 99999998jd'''''''''''''''
	99964	+ state.addr = 18446744073709545831LLU; // 99999998jl'''''''''''''''
100187	99965	break;
100188	99966	}
100189		- case 18446744073709545823LLU: // 99999998jd'''''''''''''''
	99967	+ case 18446744073709545831LLU: // 99999998jl'''''''''''''''
100190	99968	{
100191	99969	{
100192	99970	uint64_t arg = 59LLU;

		@@ -100200,7 +99978,7 @@
100200	99978	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100201	99979	}
100202	99980	// 1LLU
100203		- uint64_t return_to = 18446744073709545819LLU;
	99981	+ uint64_t return_to = 18446744073709545827LLU;
100204	99982	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100205	99983	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100206	99984	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100209,26 +99987,26 @@
100209	99987	state.addr = 839519719621918720LLU; // skipws____
100210	99988	break;
100211	99989	}
100212		- case 18446744073709545819LLU: // 99999998j$'''''''''''''''
	99990	+ case 18446744073709545827LLU: // 99999998jh'''''''''''''''
100213	99991	{
100214		- state.addr = 18446744073709545820LLU; // 99999998ja'''''''''''''''
	99992	+ state.addr = 18446744073709545828LLU; // 99999998ji'''''''''''''''
100215	99993	break;
100216	99994	}
100217		- case 18446744073709545820LLU: // 99999998ja'''''''''''''''
	99995	+ case 18446744073709545828LLU: // 99999998ji'''''''''''''''
100218	99996	{
100219	99997	/result____/LOCAL_ACCESS(heap.data, 18LLU, 14LLU) = /terminator/LOCAL_ACCESS(heap.data, 18LLU, 17LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 5LLU));
100220		- state.addr = /result____/*LOCAL_ACCESS(heap.data, 18LLU, 14LLU) ? 18446744073709545818LLU : 18446744073709545817LLU;
	99998	+ state.addr = /result____/*LOCAL_ACCESS(heap.data, 18LLU, 14LLU) ? 18446744073709545826LLU : 18446744073709545825LLU;
100221	99999	break;
100222	100000	}
100223		- case 18446744073709545818LLU: // 99999998jZ'''''''''''''''
	100001	+ case 18446744073709545826LLU: // 99999998jg'''''''''''''''
100224	100002	{
100225	100003	ungetc(0, stdin);
100226	100004	heap.availilable_size_for_dynamic_objects += 0LLU;
100227	100005	heap.availilable_size_for_dynamic_objects += 0LLU;
100228		- state.addr = 18446744073709545816LLU; // 99999998jX'''''''''''''''
	100006	+ state.addr = 18446744073709545824LLU; // 99999998je'''''''''''''''
100229	100007	break;
100230	100008	}
100231		- case 18446744073709545817LLU: // 99999998jY'''''''''''''''
	100009	+ case 18446744073709545825LLU: // 99999998jf'''''''''''''''
100232	100010	{
100233	100011	{
100234	100012	uint64_t arg = 124LLU;

		@@ -100235,10 +100013,10 @@
100235	100013	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
100236	100014	}
100237	100015	/result____/LOCAL_ACCESS(heap.data, 19LLU, 14LLU) = /separator_/LOCAL_ACCESS(heap.data, 19LLU, 18LLU) != /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 5LLU));
100238		- state.addr = /result____/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) ? 18446744073709545815LLU : 18446744073709545814LLU;
	100016	+ state.addr = /result____/*LOCAL_ACCESS(heap.data, 19LLU, 14LLU) ? 18446744073709545823LLU : 18446744073709545822LLU;
100239	100017	break;
100240	100018	}
100241		- case 18446744073709545815LLU: // 99999998jW'''''''''''''''
	100019	+ case 18446744073709545823LLU: // 99999998jd'''''''''''''''
100242	100020	{
100243	100021	{
100244	100022	uint64_t mainresult = heap.data[0].elem0;

		@@ -100248,7 +100026,7 @@
100248	100026	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100249	100027	}
100250	100028	// 1LLU
100251		- uint64_t return_to = 18446744073709545812LLU;
	100029	+ uint64_t return_to = 18446744073709545820LLU;
100252	100030	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100253	100031	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100254	100032	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100257,12 +100035,12 @@
100257	100035	state.addr = 819847183515949359LLU; // reportinit
100258	100036	break;
100259	100037	}
100260		- case 18446744073709545812LLU: // 99999998jT'''''''''''''''
	100038	+ case 18446744073709545820LLU: // 99999998ja'''''''''''''''
100261	100039	{
100262		- state.addr = 18446744073709545813LLU; // 99999998jU'''''''''''''''
	100040	+ state.addr = 18446744073709545821LLU; // 99999998jb'''''''''''''''
100263	100041	break;
100264	100042	}
100265		- case 18446744073709545813LLU: // 99999998jU'''''''''''''''
	100043	+ case 18446744073709545821LLU: // 99999998jb'''''''''''''''
100266	100044	{
100267	100045	fprintf(stderr, "%s", "in definition of union ");
100268	100046	printid(stderr, /union_id__/*LOCAL_ACCESS(heap.data, 19LLU, 10LLU));

		@@ -100273,18 +100051,18 @@
100273	100051	fprintf(stderr, "%s\n", "");
100274	100052	exit(-1);
100275	100053	}
100276		- state.addr = 18446744073709545814LLU; // 99999998jV'''''''''''''''
	100054	+ state.addr = 18446744073709545822LLU; // 99999998jc'''''''''''''''
100277	100055	break;
100278	100056	}
100279		- case 18446744073709545814LLU: // 99999998jV'''''''''''''''
	100057	+ case 18446744073709545822LLU: // 99999998jc'''''''''''''''
100280	100058	{
100281	100059	// variable u64 separator_ goes out of scope
100282	100060	// emitted destructur for type u64
100283	100061	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference separator_ at 19
100284		- state.addr = 18446744073709545816LLU; // 99999998jX'''''''''''''''
	100062	+ state.addr = 18446744073709545824LLU; // 99999998je'''''''''''''''
100285	100063	break;
100286	100064	}
100287		- case 18446744073709545816LLU: // 99999998jX'''''''''''''''
	100065	+ case 18446744073709545824LLU: // 99999998je'''''''''''''''
100288	100066	{
100289	100067	// variable u64 terminator goes out of scope
100290	100068	// emitted destructur for type u64

		@@ -100299,14 +100077,14 @@
100299	100077	uint64_t arg = 0;
100300	100078	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
100301	100079	}
100302		- state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
	100080	+ state.addr = 18446744073709545818LLU; // 99999998jZ'''''''''''''''
100303	100081	break;
100304	100082	}
100305		- case 18446744073709545810LLU: // 99999998jR'''''''''''''''
	100083	+ case 18446744073709545818LLU: // 99999998jZ'''''''''''''''
100306	100084	{
100307	100085	if(!LOCAL_ACCESS(heap.data, 17LLU, 15LLU)/list*/)
100308	100086	{
100309		- state.addr = 18446744073709545811LLU; // 99999998jS'''''''''''''''
	100087	+ state.addr = 18446744073709545819LLU; // 99999998j$'''''''''''''''
100310	100088	break;
100311	100089	}
100312	100090	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 17LLU, 15LLU)/list/, 3);

		@@ -100318,7 +100096,7 @@
100318	100096	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100319	100097	}
100320	100098	// 1LLU
100321		- uint64_t return_to = 18446744073709545809LLU;
	100099	+ uint64_t return_to = 18446744073709545817LLU;
100322	100100	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100323	100101	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100324	100102	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100327,19 +100105,19 @@
100327	100105	state.addr = 587581796494083780LLU; // elemdef_$D
100328	100106	break;
100329	100107	}
100330		- case 18446744073709545809LLU: // 99999998jQ'''''''''''''''
	100108	+ case 18446744073709545817LLU: // 99999998jY'''''''''''''''
100331	100109	{
100332		- state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
	100110	+ state.addr = 18446744073709545818LLU; // 99999998jZ'''''''''''''''
100333	100111	break;
100334	100112	}
100335		- case 18446744073709545811LLU: // 99999998jS'''''''''''''''
	100113	+ case 18446744073709545819LLU: // 99999998j$'''''''''''''''
100336	100114	{
100337	100115	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
100338	100116	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defpars___ at 16
100339		- state.addr = 18446744073709545932LLU; // 99999998lL'''''''''''''''
	100117	+ state.addr = 18446744073709545940LLU; // 99999998lT'''''''''''''''
100340	100118	break;
100341	100119	}
100342		- case 18446744073709545931LLU: // 99999998lK'''''''''''''''
	100120	+ case 18446744073709545939LLU: // 99999998lS'''''''''''''''
100343	100121	{
100344	100122	{
100345	100123	uint64_t arg = 0LLU;

		@@ -100357,7 +100135,7 @@
100357	100135	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100358	100136	}
100359	100137	// 2LLU
100360		- uint64_t return_to = 18446744073709545806LLU;
	100138	+ uint64_t return_to = 18446744073709545814LLU;
100361	100139	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100362	100140	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100363	100141	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100366,12 +100144,12 @@
100366	100144	state.addr = 621679233931860255LLU; // gendestrid
100367	100145	break;
100368	100146	}
100369		- case 18446744073709545806LLU: // 99999998jN'''''''''''''''
	100147	+ case 18446744073709545814LLU: // 99999998jV'''''''''''''''
100370	100148	{
100371		- state.addr = 18446744073709545807LLU; // 99999998jO'''''''''''''''
	100149	+ state.addr = 18446744073709545815LLU; // 99999998jW'''''''''''''''
100372	100150	break;
100373	100151	}
100374		- case 18446744073709545807LLU: // 99999998jO'''''''''''''''
	100152	+ case 18446744073709545815LLU: // 99999998jW'''''''''''''''
100375	100153	{
100376	100154	{
100377	100155	uint64_t mainresult = heap.data[0].elem0;

		@@ -100381,7 +100159,7 @@
100381	100159	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100382	100160	}
100383	100161	// 1LLU
100384		- uint64_t return_to = 18446744073709545804LLU;
	100162	+ uint64_t return_to = 18446744073709545812LLU;
100385	100163	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100386	100164	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100387	100165	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100390,12 +100168,12 @@
100390	100168	state.addr = 587881345921715008LLU; // emitenter_
100391	100169	break;
100392	100170	}
100393		- case 18446744073709545804LLU: // 99999998jL'''''''''''''''
	100171	+ case 18446744073709545812LLU: // 99999998jT'''''''''''''''
100394	100172	{
100395		- state.addr = 18446744073709545805LLU; // 99999998jM'''''''''''''''
	100173	+ state.addr = 18446744073709545813LLU; // 99999998jU'''''''''''''''
100396	100174	break;
100397	100175	}
100398		- case 18446744073709545805LLU: // 99999998jM'''''''''''''''
	100176	+ case 18446744073709545813LLU: // 99999998jU'''''''''''''''
100399	100177	{
100400	100178	{
100401	100179	uint64_t arg = 1LLU;

		@@ -100434,7 +100212,7 @@
100434	100212	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100435	100213	}
100436	100214	// 4LLU
100437		- uint64_t return_to = 18446744073709545801LLU;
	100215	+ uint64_t return_to = 18446744073709545809LLU;
100438	100216	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100439	100217	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100440	100218	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100443,12 +100221,12 @@
100443	100221	state.addr = 587881359725559808LLU; // emitref___
100444	100222	break;
100445	100223	}
100446		- case 18446744073709545801LLU: // 99999998jI'''''''''''''''
	100224	+ case 18446744073709545809LLU: // 99999998jQ'''''''''''''''
100447	100225	{
100448		- state.addr = 18446744073709545802LLU; // 99999998jJ'''''''''''''''
	100226	+ state.addr = 18446744073709545810LLU; // 99999998jR'''''''''''''''
100449	100227	break;
100450	100228	}
100451		- case 18446744073709545802LLU: // 99999998jJ'''''''''''''''
	100229	+ case 18446744073709545810LLU: // 99999998jR'''''''''''''''
100452	100230	{
100453	100231	fprintf(stdout, "%s", ");");
100454	100232	{

		@@ -100476,7 +100254,7 @@
100476	100254	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100477	100255	}
100478	100256	// 4LLU
100479		- uint64_t return_to = 18446744073709545799LLU;
	100257	+ uint64_t return_to = 18446744073709545807LLU;
100480	100258	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100481	100259	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100482	100260	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100485,12 +100263,12 @@
100485	100263	state.addr = 587881359725559808LLU; // emitref___
100486	100264	break;
100487	100265	}
100488		- case 18446744073709545799LLU: // 99999998jG'''''''''''''''
	100266	+ case 18446744073709545807LLU: // 99999998jO'''''''''''''''
100489	100267	{
100490		- state.addr = 18446744073709545800LLU; // 99999998jH'''''''''''''''
	100268	+ state.addr = 18446744073709545808LLU; // 99999998jP'''''''''''''''
100491	100269	break;
100492	100270	}
100493		- case 18446744073709545800LLU: // 99999998jH'''''''''''''''
	100271	+ case 18446744073709545808LLU: // 99999998jP'''''''''''''''
100494	100272	{
100495	100273	fprintf(stdout, "%s", " = type_data.elem1;");
100496	100274	// variable u64 zero______ goes out of scope

		@@ -100508,10 +100286,10 @@
100508	100286	// variable u64 destrargsz goes out of scope
100509	100287	// emitted destructur for type u64
100510	100288	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference destrargsz at 17
100511		- state.addr = 18446744073709545803LLU; // 99999998jK'''''''''''''''
	100289	+ state.addr = 18446744073709545811LLU; // 99999998jS'''''''''''''''
100512	100290	break;
100513	100291	}
100514		- case 18446744073709545803LLU: // 99999998jK'''''''''''''''
	100292	+ case 18446744073709545811LLU: // 99999998jS'''''''''''''''
100515	100293	{
100516	100294	fprintf(stdout, "%s", "\n type_data.elem0 &= ~4095;");
100517	100295	fprintf(stdout, "%s", "\n type_data.elem0 \|= 1732;");

		@@ -100528,7 +100306,7 @@
100528	100306	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100529	100307	}
100530	100308	// 1LLU
100531		- uint64_t return_to = 18446744073709545796LLU;
	100309	+ uint64_t return_to = 18446744073709545804LLU;
100532	100310	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100533	100311	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100534	100312	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100537,20 +100315,20 @@
100537	100315	state.addr = 587881351406074923LLU; // emitjumpup
100538	100316	break;
100539	100317	}
100540		- case 18446744073709545796LLU: // 99999998jD'''''''''''''''
	100318	+ case 18446744073709545804LLU: // 99999998jL'''''''''''''''
100541	100319	{
100542		- state.addr = 18446744073709545797LLU; // 99999998jE'''''''''''''''
	100320	+ state.addr = 18446744073709545805LLU; // 99999998jM'''''''''''''''
100543	100321	break;
100544	100322	}
100545		- case 18446744073709545797LLU: // 99999998jE'''''''''''''''
	100323	+ case 18446744073709545805LLU: // 99999998jM'''''''''''''''
100546	100324	{
100547	100325	// variable u64 level_____ goes out of scope
100548	100326	// emitted destructur for type u64
100549	100327	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 17
100550		- state.addr = 18446744073709545798LLU; // 99999998jF'''''''''''''''
	100328	+ state.addr = 18446744073709545806LLU; // 99999998jN'''''''''''''''
100551	100329	break;
100552	100330	}
100553		- case 18446744073709545798LLU: // 99999998jF'''''''''''''''
	100331	+ case 18446744073709545806LLU: // 99999998jN'''''''''''''''
100554	100332	{
100555	100333	{
100556	100334	uint64_t mainresult = heap.data[0].elem0;

		@@ -100568,7 +100346,7 @@
100568	100346	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100569	100347	}
100570	100348	// 3LLU
100571		- uint64_t return_to = 18446744073709545794LLU;
	100349	+ uint64_t return_to = 18446744073709545802LLU;
100572	100350	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100573	100351	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100574	100352	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100577,20 +100355,20 @@
100577	100355	state.addr = 788334683946154816LLU; // pushdestr_
100578	100356	break;
100579	100357	}
100580		- case 18446744073709545794LLU: // 99999998jB'''''''''''''''
	100358	+ case 18446744073709545802LLU: // 99999998jJ'''''''''''''''
100581	100359	{
100582		- state.addr = 18446744073709545795LLU; // 99999998jC'''''''''''''''
	100360	+ state.addr = 18446744073709545803LLU; // 99999998jK'''''''''''''''
100583	100361	break;
100584	100362	}
100585		- case 18446744073709545795LLU: // 99999998jC'''''''''''''''
	100363	+ case 18446744073709545803LLU: // 99999998jK'''''''''''''''
100586	100364	{
100587	100365	// variable u64 destr_id__ goes out of scope
100588	100366	// emitted destructur for type u64
100589	100367	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference destr_id__ at 16
100590		- state.addr = 18446744073709545808LLU; // 99999998jP'''''''''''''''
	100368	+ state.addr = 18446744073709545816LLU; // 99999998jX'''''''''''''''
100591	100369	break;
100592	100370	}
100593		- case 18446744073709545808LLU: // 99999998jP'''''''''''''''
	100371	+ case 18446744073709545816LLU: // 99999998jX'''''''''''''''
100594	100372	{
100595	100373	{
100596	100374	uint64_t arg = 0LLU;

		@@ -100608,7 +100386,7 @@
100608	100386	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100609	100387	}
100610	100388	// 2LLU
100611		- uint64_t return_to = 18446744073709545791LLU;
	100389	+ uint64_t return_to = 18446744073709545799LLU;
100612	100390	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100613	100391	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100614	100392	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100617,12 +100395,12 @@
100617	100395	state.addr = 517555828430075934LLU; // assign_dec
100618	100396	break;
100619	100397	}
100620		- case 18446744073709545791LLU: // 99999998i9'''''''''''''''
	100398	+ case 18446744073709545799LLU: // 99999998jG'''''''''''''''
100621	100399	{
100622		- state.addr = 18446744073709545792LLU; // 99999998j_'''''''''''''''
	100400	+ state.addr = 18446744073709545800LLU; // 99999998jH'''''''''''''''
100623	100401	break;
100624	100402	}
100625		- case 18446744073709545792LLU: // 99999998j_'''''''''''''''
	100403	+ case 18446744073709545800LLU: // 99999998jH'''''''''''''''
100626	100404	{
100627	100405	{
100628	100406	uint64_t arg = 0LLU;

		@@ -100640,7 +100418,7 @@
100640	100418	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100641	100419	}
100642	100420	// 2LLU
100643		- uint64_t return_to = 18446744073709545789LLU;
	100421	+ uint64_t return_to = 18446744073709545797LLU;
100644	100422	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100645	100423	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100646	100424	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100649,12 +100427,12 @@
100649	100427	state.addr = 621679175848052672LLU; // gencompid_
100650	100428	break;
100651	100429	}
100652		- case 18446744073709545789LLU: // 99999998i7'''''''''''''''
	100430	+ case 18446744073709545797LLU: // 99999998jE'''''''''''''''
100653	100431	{
100654		- state.addr = 18446744073709545790LLU; // 99999998i8'''''''''''''''
	100432	+ state.addr = 18446744073709545798LLU; // 99999998jF'''''''''''''''
100655	100433	break;
100656	100434	}
100657		- case 18446744073709545790LLU: // 99999998i8'''''''''''''''
	100435	+ case 18446744073709545798LLU: // 99999998jF'''''''''''''''
100658	100436	{
100659	100437	{
100660	100438	uint64_t mainresult = heap.data[0].elem0;

		@@ -100664,7 +100442,7 @@
100664	100442	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100665	100443	}
100666	100444	// 1LLU
100667		- uint64_t return_to = 18446744073709545787LLU;
	100445	+ uint64_t return_to = 18446744073709545795LLU;
100668	100446	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100669	100447	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100670	100448	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100673,12 +100451,12 @@
100673	100451	state.addr = 587881345921715008LLU; // emitenter_
100674	100452	break;
100675	100453	}
100676		- case 18446744073709545787LLU: // 99999998i5'''''''''''''''
	100454	+ case 18446744073709545795LLU: // 99999998jC'''''''''''''''
100677	100455	{
100678		- state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
	100456	+ state.addr = 18446744073709545796LLU; // 99999998jD'''''''''''''''
100679	100457	break;
100680	100458	}
100681		- case 18446744073709545788LLU: // 99999998i6'''''''''''''''
	100459	+ case 18446744073709545796LLU: // 99999998jD'''''''''''''''
100682	100460	{
100683	100461	{
100684	100462	uint64_t arg = 3LLU;

		@@ -100726,7 +100504,7 @@
100726	100504	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100727	100505	}
100728	100506	// 4LLU
100729		- uint64_t return_to = 18446744073709545785LLU;
	100507	+ uint64_t return_to = 18446744073709545793LLU;
100730	100508	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100731	100509	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100732	100510	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100735,12 +100513,12 @@
100735	100513	state.addr = 587881363956563968LLU; // emitvar___
100736	100514	break;
100737	100515	}
100738		- case 18446744073709545785LLU: // 99999998i3'''''''''''''''
	100516	+ case 18446744073709545793LLU: // 99999998jA'''''''''''''''
100739	100517	{
100740		- state.addr = 18446744073709545786LLU; // 99999998i4'''''''''''''''
	100518	+ state.addr = 18446744073709545794LLU; // 99999998jB'''''''''''''''
100741	100519	break;
100742	100520	}
100743		- case 18446744073709545786LLU: // 99999998i4'''''''''''''''
	100521	+ case 18446744073709545794LLU: // 99999998jB'''''''''''''''
100744	100522	{
100745	100523	fprintf(stdout, "%s", ", 0LLU));\n");
100746	100524	fprintf(stdout, "%s", "\n uint64_t constructor2 = *access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, ");

		@@ -100764,7 +100542,7 @@
100764	100542	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100765	100543	}
100766	100544	// 4LLU
100767		- uint64_t return_to = 18446744073709545783LLU;
	100545	+ uint64_t return_to = 18446744073709545791LLU;
100768	100546	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100769	100547	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100770	100548	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100773,12 +100551,12 @@
100773	100551	state.addr = 587881363956563968LLU; // emitvar___
100774	100552	break;
100775	100553	}
100776		- case 18446744073709545783LLU: // 99999998i1'''''''''''''''
	100554	+ case 18446744073709545791LLU: // 99999998i9'''''''''''''''
100777	100555	{
100778		- state.addr = 18446744073709545784LLU; // 99999998i2'''''''''''''''
	100556	+ state.addr = 18446744073709545792LLU; // 99999998j_'''''''''''''''
100779	100557	break;
100780	100558	}
100781		- case 18446744073709545784LLU: // 99999998i2'''''''''''''''
	100559	+ case 18446744073709545792LLU: // 99999998j_'''''''''''''''
100782	100560	{
100783	100561	fprintf(stdout, "%s", ", 0LLU));\n");
100784	100562	fprintf(stdout, "%s", "\n ");

		@@ -100802,7 +100580,7 @@
100802	100580	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100803	100581	}
100804	100582	// 4LLU
100805		- uint64_t return_to = 18446744073709545781LLU;
	100583	+ uint64_t return_to = 18446744073709545789LLU;
100806	100584	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100807	100585	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100808	100586	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100811,12 +100589,12 @@
100811	100589	state.addr = 587881359725559808LLU; // emitref___
100812	100590	break;
100813	100591	}
100814		- case 18446744073709545781LLU: // 99999998iz'''''''''''''''
	100592	+ case 18446744073709545789LLU: // 99999998i7'''''''''''''''
100815	100593	{
100816		- state.addr = 18446744073709545782LLU; // 99999998i0'''''''''''''''
	100594	+ state.addr = 18446744073709545790LLU; // 99999998i8'''''''''''''''
100817	100595	break;
100818	100596	}
100819		- case 18446744073709545782LLU: // 99999998i0'''''''''''''''
	100597	+ case 18446744073709545790LLU: // 99999998i8'''''''''''''''
100820	100598	{
100821	100599	fprintf(stdout, "%s", " = compare(constructor1, constructor2);");
100822	100600	fprintf(stdout, "%s", "\n }");

		@@ -100841,7 +100619,7 @@
100841	100619	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100842	100620	}
100843	100621	// 4LLU
100844		- uint64_t return_to = 18446744073709545779LLU;
	100622	+ uint64_t return_to = 18446744073709545787LLU;
100845	100623	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100846	100624	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100847	100625	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100850,12 +100628,12 @@
100850	100628	state.addr = 587881359725559808LLU; // emitref___
100851	100629	break;
100852	100630	}
100853		- case 18446744073709545779LLU: // 99999998ix'''''''''''''''
	100631	+ case 18446744073709545787LLU: // 99999998i5'''''''''''''''
100854	100632	{
100855		- state.addr = 18446744073709545780LLU; // 99999998iy'''''''''''''''
	100633	+ state.addr = 18446744073709545788LLU; // 99999998i6'''''''''''''''
100856	100634	break;
100857	100635	}
100858		- case 18446744073709545780LLU: // 99999998iy'''''''''''''''
	100636	+ case 18446744073709545788LLU: // 99999998i6'''''''''''''''
100859	100637	{
100860	100638	fprintf(stdout, "%s", "/result/)");
100861	100639	{

		@@ -100874,7 +100652,7 @@
100874	100652	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100875	100653	}
100876	100654	// 2LLU
100877		- uint64_t return_to = 18446744073709545776LLU;
	100655	+ uint64_t return_to = 18446744073709545784LLU;
100878	100656	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100879	100657	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100880	100658	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100883,20 +100661,20 @@
100883	100661	state.addr = 587881351406075392LLU; // emitjump2_
100884	100662	break;
100885	100663	}
100886		- case 18446744073709545776LLU: // 99999998iu'''''''''''''''
	100664	+ case 18446744073709545784LLU: // 99999998i2'''''''''''''''
100887	100665	{
100888		- state.addr = 18446744073709545777LLU; // 99999998iv'''''''''''''''
	100666	+ state.addr = 18446744073709545785LLU; // 99999998i3'''''''''''''''
100889	100667	break;
100890	100668	}
100891		- case 18446744073709545777LLU: // 99999998iv'''''''''''''''
	100669	+ case 18446744073709545785LLU: // 99999998i3'''''''''''''''
100892	100670	{
100893	100671	// variable u64 level_____ goes out of scope
100894	100672	// emitted destructur for type u64
100895	100673	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 24
100896		- state.addr = 18446744073709545778LLU; // 99999998iw'''''''''''''''
	100674	+ state.addr = 18446744073709545786LLU; // 99999998i4'''''''''''''''
100897	100675	break;
100898	100676	}
100899		- case 18446744073709545778LLU: // 99999998iw'''''''''''''''
	100677	+ case 18446744073709545786LLU: // 99999998i4'''''''''''''''
100900	100678	{
100901	100679	fprintf(stdout, "%s", "\n {");
100902	100680	fprintf(stdout, "%s", "\n uint64_t variantaddr = *access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, ");

		@@ -100920,7 +100698,7 @@
100920	100698	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100921	100699	}
100922	100700	// 4LLU
100923		- uint64_t return_to = 18446744073709545774LLU;
	100701	+ uint64_t return_to = 18446744073709545782LLU;
100924	100702	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100925	100703	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100926	100704	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100929,12 +100707,12 @@
100929	100707	state.addr = 587881363956563968LLU; // emitvar___
100930	100708	break;
100931	100709	}
100932		- case 18446744073709545774LLU: // 99999998is'''''''''''''''
	100710	+ case 18446744073709545782LLU: // 99999998i0'''''''''''''''
100933	100711	{
100934		- state.addr = 18446744073709545775LLU; // 99999998it'''''''''''''''
	100712	+ state.addr = 18446744073709545783LLU; // 99999998i1'''''''''''''''
100935	100713	break;
100936	100714	}
100937		- case 18446744073709545775LLU: // 99999998it'''''''''''''''
	100715	+ case 18446744073709545783LLU: // 99999998i1'''''''''''''''
100938	100716	{
100939	100717	fprintf(stdout, "%s", ", 0LLU));\n");
100940	100718	fprintf(stdout, "%s", "\n variantaddr &= ~4095;");

		@@ -100961,7 +100739,7 @@
100961	100739	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100962	100740	}
100963	100741	// 4LLU
100964		- uint64_t return_to = 18446744073709545772LLU;
	100742	+ uint64_t return_to = 18446744073709545780LLU;
100965	100743	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
100966	100744	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
100967	100745	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -100970,12 +100748,12 @@
100970	100748	state.addr = 587881363956563968LLU; // emitvar___
100971	100749	break;
100972	100750	}
100973		- case 18446744073709545772LLU: // 99999998iq'''''''''''''''
	100751	+ case 18446744073709545780LLU: // 99999998iy'''''''''''''''
100974	100752	{
100975		- state.addr = 18446744073709545773LLU; // 99999998ir'''''''''''''''
	100753	+ state.addr = 18446744073709545781LLU; // 99999998iz'''''''''''''''
100976	100754	break;
100977	100755	}
100978		- case 18446744073709545773LLU: // 99999998ir'''''''''''''''
	100756	+ case 18446744073709545781LLU: // 99999998iz'''''''''''''''
100979	100757	{
100980	100758	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, 2LLU, ");
100981	100759	{

		@@ -100998,7 +100776,7 @@
100998	100776	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
100999	100777	}
101000	100778	// 4LLU
101001		- uint64_t return_to = 18446744073709545770LLU;
	100779	+ uint64_t return_to = 18446744073709545778LLU;
101002	100780	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101003	100781	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101004	100782	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101007,12 +100785,12 @@
101007	100785	state.addr = 587881363956563968LLU; // emitvar___
101008	100786	break;
101009	100787	}
101010		- case 18446744073709545770LLU: // 99999998io'''''''''''''''
	100788	+ case 18446744073709545778LLU: // 99999998iw'''''''''''''''
101011	100789	{
101012		- state.addr = 18446744073709545771LLU; // 99999998ip'''''''''''''''
	100790	+ state.addr = 18446744073709545779LLU; // 99999998ix'''''''''''''''
101013	100791	break;
101014	100792	}
101015		- case 18446744073709545771LLU: // 99999998ip'''''''''''''''
	100793	+ case 18446744073709545779LLU: // 99999998ix'''''''''''''''
101016	100794	{
101017	100795	fprintf(stdout, "%s", ", 1LLU);\n");
101018	100796	fprintf(stdout, "%s", "\n ");

		@@ -101036,7 +100814,7 @@
101036	100814	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101037	100815	}
101038	100816	// 4LLU
101039		- uint64_t return_to = 18446744073709545768LLU;
	100817	+ uint64_t return_to = 18446744073709545776LLU;
101040	100818	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101041	100819	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101042	100820	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101045,12 +100823,12 @@
101045	100823	state.addr = 587881363956563968LLU; // emitvar___
101046	100824	break;
101047	100825	}
101048		- case 18446744073709545768LLU: // 99999998im'''''''''''''''
	100826	+ case 18446744073709545776LLU: // 99999998iu'''''''''''''''
101049	100827	{
101050		- state.addr = 18446744073709545769LLU; // 99999998in'''''''''''''''
	100828	+ state.addr = 18446744073709545777LLU; // 99999998iv'''''''''''''''
101051	100829	break;
101052	100830	}
101053		- case 18446744073709545769LLU: // 99999998in'''''''''''''''
	100831	+ case 18446744073709545777LLU: // 99999998iv'''''''''''''''
101054	100832	{
101055	100833	fprintf(stdout, "%s", " = tree_elem_addr(heap.data, 2LLU, ");
101056	100834	{

		@@ -101073,7 +100851,7 @@
101073	100851	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101074	100852	}
101075	100853	// 4LLU
101076		- uint64_t return_to = 18446744073709545766LLU;
	100854	+ uint64_t return_to = 18446744073709545774LLU;
101077	100855	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101078	100856	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101079	100857	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101082,12 +100860,12 @@
101082	100860	state.addr = 587881363956563968LLU; // emitvar___
101083	100861	break;
101084	100862	}
101085		- case 18446744073709545766LLU: // 99999998ik'''''''''''''''
	100863	+ case 18446744073709545774LLU: // 99999998is'''''''''''''''
101086	100864	{
101087		- state.addr = 18446744073709545767LLU; // 99999998il'''''''''''''''
	100865	+ state.addr = 18446744073709545775LLU; // 99999998it'''''''''''''''
101088	100866	break;
101089	100867	}
101090		- case 18446744073709545767LLU: // 99999998il'''''''''''''''
	100868	+ case 18446744073709545775LLU: // 99999998it'''''''''''''''
101091	100869	{
101092	100870	fprintf(stdout, "%s", ", 1LLU);\n");
101093	100871	fprintf(stdout, "%s", "\n }");

		@@ -101103,7 +100881,7 @@
101103	100881	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101104	100882	}
101105	100883	// 1LLU
101106		- uint64_t return_to = 18446744073709545763LLU;
	100884	+ uint64_t return_to = 18446744073709545771LLU;
101107	100885	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101108	100886	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101109	100887	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101112,20 +100890,20 @@
101112	100890	state.addr = 587881351406074923LLU; // emitjumpup
101113	100891	break;
101114	100892	}
101115		- case 18446744073709545763LLU: // 99999998ih'''''''''''''''
	100893	+ case 18446744073709545771LLU: // 99999998ip'''''''''''''''
101116	100894	{
101117		- state.addr = 18446744073709545764LLU; // 99999998ii'''''''''''''''
	100895	+ state.addr = 18446744073709545772LLU; // 99999998iq'''''''''''''''
101118	100896	break;
101119	100897	}
101120		- case 18446744073709545764LLU: // 99999998ii'''''''''''''''
	100898	+ case 18446744073709545772LLU: // 99999998iq'''''''''''''''
101121	100899	{
101122	100900	// variable u64 level_____ goes out of scope
101123	100901	// emitted destructur for type u64
101124	100902	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 24
101125		- state.addr = 18446744073709545765LLU; // 99999998ij'''''''''''''''
	100903	+ state.addr = 18446744073709545773LLU; // 99999998ir'''''''''''''''
101126	100904	break;
101127	100905	}
101128		- case 18446744073709545765LLU: // 99999998ij'''''''''''''''
	100906	+ case 18446744073709545773LLU: // 99999998ir'''''''''''''''
101129	100907	{
101130	100908	{
101131	100909	uint64_t mainresult = heap.data[0].elem0;

		@@ -101135,7 +100913,7 @@
101135	100913	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101136	100914	}
101137	100915	// 1LLU
101138		- uint64_t return_to = 18446744073709545761LLU;
	100916	+ uint64_t return_to = 18446744073709545769LLU;
101139	100917	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101140	100918	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101141	100919	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101144,12 +100922,12 @@
101144	100922	state.addr = 587881345921715008LLU; // emitenter_
101145	100923	break;
101146	100924	}
101147		- case 18446744073709545761LLU: // 99999998if'''''''''''''''
	100925	+ case 18446744073709545769LLU: // 99999998in'''''''''''''''
101148	100926	{
101149		- state.addr = 18446744073709545762LLU; // 99999998ig'''''''''''''''
	100927	+ state.addr = 18446744073709545770LLU; // 99999998io'''''''''''''''
101150	100928	break;
101151	100929	}
101152		- case 18446744073709545762LLU: // 99999998ig'''''''''''''''
	100930	+ case 18446744073709545770LLU: // 99999998io'''''''''''''''
101153	100931	{
101154	100932	{
101155	100933	uint64_t arg = 0LLU;

		@@ -101175,7 +100953,7 @@
101175	100953	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101176	100954	}
101177	100955	// 4LLU
101178		- uint64_t return_to = 18446744073709545758LLU;
	100956	+ uint64_t return_to = 18446744073709545766LLU;
101179	100957	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101180	100958	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101181	100959	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101184,12 +100962,12 @@
101184	100962	state.addr = 587881357748664875LLU; // emitpoptmp
101185	100963	break;
101186	100964	}
101187		- case 18446744073709545758LLU: // 99999998ic'''''''''''''''
	100965	+ case 18446744073709545766LLU: // 99999998ik'''''''''''''''
101188	100966	{
101189		- state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
	100967	+ state.addr = 18446744073709545767LLU; // 99999998il'''''''''''''''
101190	100968	break;
101191	100969	}
101192		- case 18446744073709545759LLU: // 99999998id'''''''''''''''
	100970	+ case 18446744073709545767LLU: // 99999998il'''''''''''''''
101193	100971	{
101194	100972	{
101195	100973	uint64_t mainresult = heap.data[0].elem0;

		@@ -101211,7 +100989,7 @@
101211	100989	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101212	100990	}
101213	100991	// 4LLU
101214		- uint64_t return_to = 18446744073709545756LLU;
	100992	+ uint64_t return_to = 18446744073709545764LLU;
101215	100993	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101216	100994	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101217	100995	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101220,12 +100998,12 @@
101220	100998	state.addr = 587881357748664875LLU; // emitpoptmp
101221	100999	break;
101222	101000	}
101223		- case 18446744073709545756LLU: // 99999998ia'''''''''''''''
	101001	+ case 18446744073709545764LLU: // 99999998ii'''''''''''''''
101224	101002	{
101225		- state.addr = 18446744073709545757LLU; // 99999998ib'''''''''''''''
	101003	+ state.addr = 18446744073709545765LLU; // 99999998ij'''''''''''''''
101226	101004	break;
101227	101005	}
101228		- case 18446744073709545757LLU: // 99999998ib'''''''''''''''
	101006	+ case 18446744073709545765LLU: // 99999998ij'''''''''''''''
101229	101007	{
101230	101008	{
101231	101009	uint64_t mainresult = heap.data[0].elem0;

		@@ -101247,7 +101025,7 @@
101247	101025	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101248	101026	}
101249	101027	// 4LLU
101250		- uint64_t return_to = 18446744073709545754LLU;
	101028	+ uint64_t return_to = 18446744073709545762LLU;
101251	101029	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101252	101030	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101253	101031	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101256,20 +101034,20 @@
101256	101034	state.addr = 587881357748664875LLU; // emitpoptmp
101257	101035	break;
101258	101036	}
101259		- case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
	101037	+ case 18446744073709545762LLU: // 99999998ig'''''''''''''''
101260	101038	{
101261		- state.addr = 18446744073709545755LLU; // 99999998i$'''''''''''''''
	101039	+ state.addr = 18446744073709545763LLU; // 99999998ih'''''''''''''''
101262	101040	break;
101263	101041	}
101264		- case 18446744073709545755LLU: // 99999998i$'''''''''''''''
	101042	+ case 18446744073709545763LLU: // 99999998ih'''''''''''''''
101265	101043	{
101266	101044	// variable u64 level_____ goes out of scope
101267	101045	// emitted destructur for type u64
101268	101046	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 24
101269		- state.addr = 18446744073709545760LLU; // 99999998ie'''''''''''''''
	101047	+ state.addr = 18446744073709545768LLU; // 99999998im'''''''''''''''
101270	101048	break;
101271	101049	}
101272		- case 18446744073709545760LLU: // 99999998ie'''''''''''''''
	101050	+ case 18446744073709545768LLU: // 99999998im'''''''''''''''
101273	101051	{
101274	101052	{
101275	101053	uint64_t mainresult = heap.data[0].elem0;

		@@ -101287,7 +101065,7 @@
101287	101065	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101288	101066	}
101289	101067	// 3LLU
101290		- uint64_t return_to = 18446744073709545752LLU;
	101068	+ uint64_t return_to = 18446744073709545760LLU;
101291	101069	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101292	101070	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101293	101071	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101296,12 +101074,12 @@
101296	101074	state.addr = 587881353282000896LLU; // emitleave_
101297	101075	break;
101298	101076	}
101299		- case 18446744073709545752LLU: // 99999998iX'''''''''''''''
	101077	+ case 18446744073709545760LLU: // 99999998ie'''''''''''''''
101300	101078	{
101301		- state.addr = 18446744073709545753LLU; // 99999998iY'''''''''''''''
	101079	+ state.addr = 18446744073709545761LLU; // 99999998if'''''''''''''''
101302	101080	break;
101303	101081	}
101304		- case 18446744073709545753LLU: // 99999998iY'''''''''''''''
	101082	+ case 18446744073709545761LLU: // 99999998if'''''''''''''''
101305	101083	{
101306	101084	{
101307	101085	uint64_t mainresult = heap.data[0].elem0;

		@@ -101319,7 +101097,7 @@
101319	101097	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101320	101098	}
101321	101099	// 3LLU
101322		- uint64_t return_to = 18446744073709545750LLU;
	101100	+ uint64_t return_to = 18446744073709545758LLU;
101323	101101	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101324	101102	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101325	101103	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101328,12 +101106,12 @@
101328	101106	state.addr = 788334683946154816LLU; // pushdestr_
101329	101107	break;
101330	101108	}
101331		- case 18446744073709545750LLU: // 99999998iV'''''''''''''''
	101109	+ case 18446744073709545758LLU: // 99999998ic'''''''''''''''
101332	101110	{
101333		- state.addr = 18446744073709545751LLU; // 99999998iW'''''''''''''''
	101111	+ state.addr = 18446744073709545759LLU; // 99999998id'''''''''''''''
101334	101112	break;
101335	101113	}
101336		- case 18446744073709545751LLU: // 99999998iW'''''''''''''''
	101114	+ case 18446744073709545759LLU: // 99999998id'''''''''''''''
101337	101115	{
101338	101116	// variable u64 idx2______ goes out of scope
101339	101117	// emitted destructur for type u64

		@@ -101359,10 +101137,10 @@
101359	101137	// variable u64 skiplabel_ goes out of scope
101360	101138	// emitted destructur for type u64
101361	101139	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference skiplabel_ at 16
101362		- state.addr = 18446744073709545793LLU; // 99999998jA'''''''''''''''
	101140	+ state.addr = 18446744073709545801LLU; // 99999998jI'''''''''''''''
101363	101141	break;
101364	101142	}
101365		- case 18446744073709545793LLU: // 99999998jA'''''''''''''''
	101143	+ case 18446744073709545801LLU: // 99999998jI'''''''''''''''
101366	101144	{
101367	101145	{
101368	101146	uint64_t mainresult = heap.data[0].elem0;

		@@ -101384,7 +101162,7 @@
101384	101162	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101385	101163	}
101386	101164	// 4LLU
101387		- uint64_t return_to = 18446744073709545748LLU;
	101165	+ uint64_t return_to = 18446744073709545756LLU;
101388	101166	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101389	101167	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101390	101168	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101393,12 +101171,12 @@
101393	101171	state.addr = 788334702348118639LLU; // pushuniont
101394	101172	break;
101395	101173	}
101396		- case 18446744073709545748LLU: // 99999998iT'''''''''''''''
	101174	+ case 18446744073709545756LLU: // 99999998ia'''''''''''''''
101397	101175	{
101398		- state.addr = 18446744073709545749LLU; // 99999998iU'''''''''''''''
	101176	+ state.addr = 18446744073709545757LLU; // 99999998ib'''''''''''''''
101399	101177	break;
101400	101178	}
101401		- case 18446744073709545749LLU: // 99999998iU'''''''''''''''
	101179	+ case 18446744073709545757LLU: // 99999998ib'''''''''''''''
101402	101180	{
101403	101181	// variable u64 result____ goes out of scope
101404	101182	// emitted destructur for type u64

		@@ -101416,22 +101194,22 @@
101416	101194	uint64_t arg = 0;
101417	101195	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
101418	101196	}
101419		- state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
	101197	+ state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
101420	101198	break;
101421	101199	}
101422		- case 18446744073709545746LLU: // 99999998iR'''''''''''''''
	101200	+ case 18446744073709545754LLU: // 99999998iZ'''''''''''''''
101423	101201	{
101424	101202	if(!LOCAL_ACCESS(heap.data, 13LLU, 11LLU)/list*/)
101425	101203	{
101426		- state.addr = 18446744073709545747LLU; // 99999998iS'''''''''''''''
	101204	+ state.addr = 18446744073709545755LLU; // 99999998i$'''''''''''''''
101427	101205	break;
101428	101206	}
101429	101207	LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 11LLU)/list/, 1);
101430	101208	// omitting u64 destructor
101431		- state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
	101209	+ state.addr = 18446744073709545754LLU; // 99999998iZ'''''''''''''''
101432	101210	break;
101433	101211	}
101434		- case 18446744073709545747LLU: // 99999998iS'''''''''''''''
	101212	+ case 18446744073709545755LLU: // 99999998i$'''''''''''''''
101435	101213	{
101436	101214	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
101437	101215	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constrs___ at 12

		@@ -101440,10 +101218,10 @@
101440	101218	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference union_id__ at 11
101441	101219	heap.availilable_size_for_dynamic_objects += 0LLU;
101442	101220	heap.availilable_size_for_dynamic_objects += 0LLU;
101443		- state.addr = 18446744073709545745LLU; // 99999998iQ'''''''''''''''
	101221	+ state.addr = 18446744073709545753LLU; // 99999998iY'''''''''''''''
101444	101222	break;
101445	101223	}
101446		- case 18446744073709545944LLU: // 99999998lX'''''''''''''''
	101224	+ case 18446744073709545952LLU: // 99999998le'''''''''''''''
101447	101225	{
101448	101226	{
101449	101227	uint64_t arg = 0LLU;

		@@ -101502,10 +101280,10 @@
101502	101280	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
101503	101281	}
101504	101282	/isunsafe__/LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /isunsafe__/LOCAL_ACCESS(heap.data, 23LLU, 22LLU) == /id________/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU);
101505		- state.addr = /isunsafe__/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545743LLU : 18446744073709545742LLU;
	101283	+ state.addr = /isunsafe__/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545751LLU : 18446744073709545750LLU;
101506	101284	break;
101507	101285	}
101508		- case 18446744073709545743LLU: // 99999998iO'''''''''''''''
	101286	+ case 18446744073709545751LLU: // 99999998iW'''''''''''''''
101509	101287	{
101510	101288	/complete__/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 0LLU;
101511	101289

		@@ -101515,15 +101293,15 @@
101515	101293
101516	101294	heap.availilable_size_for_dynamic_objects += 0LLU;
101517	101295	heap.availilable_size_for_dynamic_objects += 0LLU;
101518		- state.addr = 18446744073709545741LLU; // 99999998iM'''''''''''''''
	101296	+ state.addr = 18446744073709545749LLU; // 99999998iU'''''''''''''''
101519	101297	break;
101520	101298	}
101521		- case 18446744073709545742LLU: // 99999998iN'''''''''''''''
	101299	+ case 18446744073709545750LLU: // 99999998iV'''''''''''''''
101522	101300	{
101523		- state.addr = /iscomplete/*LOCAL_ACCESS(heap.data, 23LLU, 18LLU) ? 18446744073709545740LLU : 18446744073709545739LLU;
	101301	+ state.addr = /iscomplete/*LOCAL_ACCESS(heap.data, 23LLU, 18LLU) ? 18446744073709545748LLU : 18446744073709545747LLU;
101524	101302	break;
101525	101303	}
101526		- case 18446744073709545740LLU: // 99999998iL'''''''''''''''
	101304	+ case 18446744073709545748LLU: // 99999998iT'''''''''''''''
101527	101305	{
101528	101306	/complete__/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 1LLU;
101529	101307

		@@ -101531,15 +101309,15 @@
101531	101309
101532	101310	heap.availilable_size_for_dynamic_objects += 0LLU;
101533	101311	heap.availilable_size_for_dynamic_objects += 0LLU;
101534		- state.addr = 18446744073709545738LLU; // 99999998iJ'''''''''''''''
	101312	+ state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
101535	101313	break;
101536	101314	}
101537		- case 18446744073709545739LLU: // 99999998iK'''''''''''''''
	101315	+ case 18446744073709545747LLU: // 99999998iS'''''''''''''''
101538	101316	{
101539		- state.addr = /isfinite__/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU) ? 18446744073709545737LLU : 18446744073709545736LLU;
	101317	+ state.addr = /isfinite__/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU) ? 18446744073709545745LLU : 18446744073709545744LLU;
101540	101318	break;
101541	101319	}
101542		- case 18446744073709545737LLU: // 99999998iI'''''''''''''''
	101320	+ case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
101543	101321	{
101544	101322	/finite____/*LOCAL_ACCESS(heap.data, 23LLU, 10LLU) = 1LLU;
101545	101323

		@@ -101547,15 +101325,15 @@
101547	101325
101548	101326	heap.availilable_size_for_dynamic_objects += 0LLU;
101549	101327	heap.availilable_size_for_dynamic_objects += 0LLU;
101550		- state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
	101328	+ state.addr = 18446744073709545743LLU; // 99999998iO'''''''''''''''
101551	101329	break;
101552	101330	}
101553		- case 18446744073709545736LLU: // 99999998iH'''''''''''''''
	101331	+ case 18446744073709545744LLU: // 99999998iP'''''''''''''''
101554	101332	{
101555		- state.addr = /ispartial_/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545734LLU : 18446744073709545733LLU;
	101333	+ state.addr = /ispartial_/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545742LLU : 18446744073709545741LLU;
101556	101334	break;
101557	101335	}
101558		- case 18446744073709545734LLU: // 99999998iF'''''''''''''''
	101336	+ case 18446744073709545742LLU: // 99999998iN'''''''''''''''
101559	101337	{
101560	101338	/complete__/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 0LLU;
101561	101339

		@@ -101565,15 +101343,15 @@
101565	101343
101566	101344	heap.availilable_size_for_dynamic_objects += 0LLU;
101567	101345	heap.availilable_size_for_dynamic_objects += 0LLU;
101568		- state.addr = 18446744073709545732LLU; // 99999998iD'''''''''''''''
	101346	+ state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
101569	101347	break;
101570	101348	}
101571		- case 18446744073709545733LLU: // 99999998iE'''''''''''''''
	101349	+ case 18446744073709545741LLU: // 99999998iM'''''''''''''''
101572	101350	{
101573		- state.addr = /istotal___/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545731LLU : 18446744073709545730LLU;
	101351	+ state.addr = /istotal___/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545739LLU : 18446744073709545738LLU;
101574	101352	break;
101575	101353	}
101576		- case 18446744073709545731LLU: // 99999998iC'''''''''''''''
	101354	+ case 18446744073709545739LLU: // 99999998iK'''''''''''''''
101577	101355	{
101578	101356	/complete__/*LOCAL_ACCESS(heap.data, 23LLU, 11LLU) = 1LLU;
101579	101357

		@@ -101583,10 +101361,10 @@
101583	101361
101584	101362	heap.availilable_size_for_dynamic_objects += 0LLU;
101585	101363	heap.availilable_size_for_dynamic_objects += 0LLU;
101586		- state.addr = 18446744073709545729LLU; // 99999998iA'''''''''''''''
	101364	+ state.addr = 18446744073709545737LLU; // 99999998iI'''''''''''''''
101587	101365	break;
101588	101366	}
101589		- case 18446744073709545730LLU: // 99999998iB'''''''''''''''
	101367	+ case 18446744073709545738LLU: // 99999998iJ'''''''''''''''
101590	101368	{
101591	101369	fprintf(stderr, "%s", "missing property before ");
101592	101370	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 23LLU, 7LLU));

		@@ -101595,30 +101373,30 @@
101595	101373	fprintf(stderr, "%s\n", "");
101596	101374	exit(-1);
101597	101375	}
101598		- state.addr = 18446744073709545729LLU; // 99999998iA'''''''''''''''
	101376	+ state.addr = 18446744073709545737LLU; // 99999998iI'''''''''''''''
101599	101377	break;
101600	101378	}
101601		- case 18446744073709545729LLU: // 99999998iA'''''''''''''''
	101379	+ case 18446744073709545737LLU: // 99999998iI'''''''''''''''
101602	101380	{
101603		- state.addr = 18446744073709545732LLU; // 99999998iD'''''''''''''''
	101381	+ state.addr = 18446744073709545740LLU; // 99999998iL'''''''''''''''
101604	101382	break;
101605	101383	}
101606		- case 18446744073709545732LLU: // 99999998iD'''''''''''''''
	101384	+ case 18446744073709545740LLU: // 99999998iL'''''''''''''''
101607	101385	{
101608		- state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
	101386	+ state.addr = 18446744073709545743LLU; // 99999998iO'''''''''''''''
101609	101387	break;
101610	101388	}
101611		- case 18446744073709545735LLU: // 99999998iG'''''''''''''''
	101389	+ case 18446744073709545743LLU: // 99999998iO'''''''''''''''
101612	101390	{
101613		- state.addr = 18446744073709545738LLU; // 99999998iJ'''''''''''''''
	101391	+ state.addr = 18446744073709545746LLU; // 99999998iR'''''''''''''''
101614	101392	break;
101615	101393	}
101616		- case 18446744073709545738LLU: // 99999998iJ'''''''''''''''
	101394	+ case 18446744073709545746LLU: // 99999998iR'''''''''''''''
101617	101395	{
101618		- state.addr = 18446744073709545741LLU; // 99999998iM'''''''''''''''
	101396	+ state.addr = 18446744073709545749LLU; // 99999998iU'''''''''''''''
101619	101397	break;
101620	101398	}
101621		- case 18446744073709545741LLU: // 99999998iM'''''''''''''''
	101399	+ case 18446744073709545749LLU: // 99999998iU'''''''''''''''
101622	101400	{
101623	101401	// variable u64 isunsafe__ goes out of scope
101624	101402	// emitted destructur for type u64

		@@ -101635,10 +101413,10 @@
101635	101413	// variable u64 iscomplete goes out of scope
101636	101414	// emitted destructur for type u64
101637	101415	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference iscomplete at 19
101638		- state.addr = 18446744073709545744LLU; // 99999998iP'''''''''''''''
	101416	+ state.addr = 18446744073709545752LLU; // 99999998iX'''''''''''''''
101639	101417	break;
101640	101418	}
101641		- case 18446744073709545744LLU: // 99999998iP'''''''''''''''
	101419	+ case 18446744073709545752LLU: // 99999998iX'''''''''''''''
101642	101420	{
101643	101421	{
101644	101422	uint64_t arg = 40LLU;

		@@ -101656,7 +101434,7 @@
101656	101434	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101657	101435	}
101658	101436	// 1LLU
101659		- uint64_t return_to = 18446744073709545726LLU;
	101437	+ uint64_t return_to = 18446744073709545734LLU;
101660	101438	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101661	101439	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101662	101440	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101665,18 +101443,18 @@
101665	101443	state.addr = 839519719621918720LLU; // skipws____
101666	101444	break;
101667	101445	}
101668		- case 18446744073709545726LLU: // 99999998h8'''''''''''''''
	101446	+ case 18446744073709545734LLU: // 99999998iF'''''''''''''''
101669	101447	{
101670		- state.addr = 18446744073709545727LLU; // 99999998h9'''''''''''''''
	101448	+ state.addr = 18446744073709545735LLU; // 99999998iG'''''''''''''''
101671	101449	break;
101672	101450	}
101673		- case 18446744073709545727LLU: // 99999998h9'''''''''''''''
	101451	+ case 18446744073709545735LLU: // 99999998iG'''''''''''''''
101674	101452	{
101675	101453	/found_____/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /sym_______/LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 5LLU));
101676		- state.addr = /found_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545725LLU : 18446744073709545724LLU;
	101454	+ state.addr = /found_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545733LLU : 18446744073709545732LLU;
101677	101455	break;
101678	101456	}
101679		- case 18446744073709545725LLU: // 99999998h7'''''''''''''''
	101457	+ case 18446744073709545733LLU: // 99999998iE'''''''''''''''
101680	101458	{
101681	101459	{
101682	101460	uint64_t arg = 0LLU;

		@@ -101706,7 +101484,7 @@
101706	101484	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101707	101485	}
101708	101486	// 5LLU
101709		- uint64_t return_to = 18446744073709545722LLU;
	101487	+ uint64_t return_to = 18446744073709545730LLU;
101710	101488	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101711	101489	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101712	101490	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101715,12 +101493,12 @@
101715	101493	state.addr = 782701543567846272LLU; // parseress_
101716	101494	break;
101717	101495	}
101718		- case 18446744073709545722LLU: // 99999998h4'''''''''''''''
	101496	+ case 18446744073709545730LLU: // 99999998iB'''''''''''''''
101719	101497	{
101720		- state.addr = 18446744073709545723LLU; // 99999998h5'''''''''''''''
	101498	+ state.addr = 18446744073709545731LLU; // 99999998iC'''''''''''''''
101721	101499	break;
101722	101500	}
101723		- case 18446744073709545723LLU: // 99999998h5'''''''''''''''
	101501	+ case 18446744073709545731LLU: // 99999998iC'''''''''''''''
101724	101502	{
101725	101503	{
101726	101504	uint64_t arg = 0LLU;

		@@ -101731,18 +101509,18 @@
101731	101509	// variable u64 resscount_ goes out of scope
101732	101510	// emitted destructur for type u64
101733	101511	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resscount_ at 22
101734		- state.addr = 18446744073709545721LLU; // 99999998h3'''''''''''''''
	101512	+ state.addr = 18446744073709545729LLU; // 99999998iA'''''''''''''''
101735	101513	break;
101736	101514	}
101737		- case 18446744073709545721LLU: // 99999998h3'''''''''''''''
	101515	+ case 18446744073709545729LLU: // 99999998iA'''''''''''''''
101738	101516	{
101739	101517	// variable u64 returnbase goes out of scope
101740	101518	// emitted destructur for type u64
101741	101519	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference returnbase at 21
101742		- state.addr = 18446744073709545724LLU; // 99999998h6'''''''''''''''
	101520	+ state.addr = 18446744073709545732LLU; // 99999998iD'''''''''''''''
101743	101521	break;
101744	101522	}
101745		- case 18446744073709545724LLU: // 99999998h6'''''''''''''''
	101523	+ case 18446744073709545732LLU: // 99999998iD'''''''''''''''
101746	101524	{
101747	101525	// variable u64 found_____ goes out of scope
101748	101526	// emitted destructur for type u64

		@@ -101750,10 +101528,10 @@
101750	101528	// variable u64 sym_______ goes out of scope
101751	101529	// emitted destructur for type u64
101752	101530	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 19
101753		- state.addr = 18446744073709545728LLU; // 99999998i_'''''''''''''''
	101531	+ state.addr = 18446744073709545736LLU; // 99999998iH'''''''''''''''
101754	101532	break;
101755	101533	}
101756		- case 18446744073709545728LLU: // 99999998i_'''''''''''''''
	101534	+ case 18446744073709545736LLU: // 99999998iH'''''''''''''''
101757	101535	{
101758	101536	{
101759	101537	uint64_t mainresult = heap.data[0].elem0;

		@@ -101763,7 +101541,7 @@
101763	101541	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101764	101542	}
101765	101543	// 1LLU
101766		- uint64_t return_to = 18446744073709545719LLU;
	101544	+ uint64_t return_to = 18446744073709545727LLU;
101767	101545	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101768	101546	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101769	101547	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101772,12 +101550,12 @@
101772	101550	state.addr = 839519719621918720LLU; // skipws____
101773	101551	break;
101774	101552	}
101775		- case 18446744073709545719LLU: // 99999998h1'''''''''''''''
	101553	+ case 18446744073709545727LLU: // 99999998h9'''''''''''''''
101776	101554	{
101777		- state.addr = 18446744073709545720LLU; // 99999998h2'''''''''''''''
	101555	+ state.addr = 18446744073709545728LLU; // 99999998i_'''''''''''''''
101778	101556	break;
101779	101557	}
101780		- case 18446744073709545720LLU: // 99999998h2'''''''''''''''
	101558	+ case 18446744073709545728LLU: // 99999998i_'''''''''''''''
101781	101559	{
101782	101560	/id________/LOCAL_ACCESS(heap.data, 18LLU, 7LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)));
101783	101561	{

		@@ -101800,7 +101578,7 @@
101800	101578	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101801	101579	}
101802	101580	// 1LLU
101803		- uint64_t return_to = 18446744073709545717LLU;
	101581	+ uint64_t return_to = 18446744073709545725LLU;
101804	101582	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101805	101583	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101806	101584	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101809,18 +101587,18 @@
101809	101587	state.addr = 839519719621918720LLU; // skipws____
101810	101588	break;
101811	101589	}
101812		- case 18446744073709545717LLU: // 99999998hz'''''''''''''''
	101590	+ case 18446744073709545725LLU: // 99999998h7'''''''''''''''
101813	101591	{
101814		- state.addr = 18446744073709545718LLU; // 99999998h0'''''''''''''''
	101592	+ state.addr = 18446744073709545726LLU; // 99999998h8'''''''''''''''
101815	101593	break;
101816	101594	}
101817		- case 18446744073709545718LLU: // 99999998h0'''''''''''''''
	101595	+ case 18446744073709545726LLU: // 99999998h8'''''''''''''''
101818	101596	{
101819	101597	/matchsym__/LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /sym_______/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 5LLU));
101820		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709545716LLU : 18446744073709545715LLU;
	101598	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709545724LLU : 18446744073709545723LLU;
101821	101599	break;
101822	101600	}
101823		- case 18446744073709545716LLU: // 99999998hy'''''''''''''''
	101601	+ case 18446744073709545724LLU: // 99999998h6'''''''''''''''
101824	101602	{
101825	101603	{
101826	101604	uint64_t arg = 0LLU;

		@@ -101842,7 +101620,7 @@
101842	101620	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101843	101621	}
101844	101622	// 3LLU
101845		- uint64_t return_to = 18446744073709545713LLU;
	101623	+ uint64_t return_to = 18446744073709545721LLU;
101846	101624	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101847	101625	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101848	101626	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101851,12 +101629,12 @@
101851	101629	state.addr = 782701543585622638LLU; // parsesigns
101852	101630	break;
101853	101631	}
101854		- case 18446744073709545713LLU: // 99999998hv'''''''''''''''
	101632	+ case 18446744073709545721LLU: // 99999998h3'''''''''''''''
101855	101633	{
101856		- state.addr = 18446744073709545714LLU; // 99999998hw'''''''''''''''
	101634	+ state.addr = 18446744073709545722LLU; // 99999998h4'''''''''''''''
101857	101635	break;
101858	101636	}
101859		- case 18446744073709545714LLU: // 99999998hw'''''''''''''''
	101637	+ case 18446744073709545722LLU: // 99999998h4'''''''''''''''
101860	101638	{
101861	101639	/sym_______/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU) = 45LLU;
101862	101640

		@@ -101868,7 +101646,7 @@
101868	101646	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101869	101647	}
101870	101648	// 1LLU
101871		- uint64_t return_to = 18446744073709545711LLU;
	101649	+ uint64_t return_to = 18446744073709545719LLU;
101872	101650	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101873	101651	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101874	101652	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101877,33 +101655,33 @@
101877	101655	state.addr = 839519719621918720LLU; // skipws____
101878	101656	break;
101879	101657	}
101880		- case 18446744073709545711LLU: // 99999998ht'''''''''''''''
	101658	+ case 18446744073709545719LLU: // 99999998h1'''''''''''''''
101881	101659	{
101882		- state.addr = 18446744073709545712LLU; // 99999998hu'''''''''''''''
	101660	+ state.addr = 18446744073709545720LLU; // 99999998h2'''''''''''''''
101883	101661	break;
101884	101662	}
101885		- case 18446744073709545712LLU: // 99999998hu'''''''''''''''
	101663	+ case 18446744073709545720LLU: // 99999998h2'''''''''''''''
101886	101664	{
101887	101665	/matchsym__/LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /sym_______/LOCAL_ACCESS(heap.data, 22LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 5LLU));
101888		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709545710LLU : 18446744073709545709LLU;
	101666	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709545718LLU : 18446744073709545717LLU;
101889	101667	break;
101890	101668	}
101891		- case 18446744073709545710LLU: // 99999998hs'''''''''''''''
	101669	+ case 18446744073709545718LLU: // 99999998h0'''''''''''''''
101892	101670	{
101893	101671	matchid("->", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
101894		- state.addr = /defargcnt_/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU) ? 18446744073709545708LLU : 18446744073709545707LLU;
	101672	+ state.addr = /defargcnt_/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU) ? 18446744073709545716LLU : 18446744073709545715LLU;
101895	101673	break;
101896	101674	}
101897		- case 18446744073709545708LLU: // 99999998hq'''''''''''''''
	101675	+ case 18446744073709545716LLU: // 99999998hy'''''''''''''''
101898	101676	{
101899	101677	{
101900	101678	fprintf(stderr, "%s\n", "can't mix (c) f(a) with f :: (a) -> (c) syntax");
101901	101679	exit(-1);
101902	101680	}
101903		- state.addr = 18446744073709545707LLU; // 99999998hp'''''''''''''''
	101681	+ state.addr = 18446744073709545715LLU; // 99999998hx'''''''''''''''
101904	101682	break;
101905	101683	}
101906		- case 18446744073709545707LLU: // 99999998hp'''''''''''''''
	101684	+ case 18446744073709545715LLU: // 99999998hx'''''''''''''''
101907	101685	{
101908	101686	{
101909	101687	uint64_t mainresult = heap.data[0].elem0;

		@@ -101913,7 +101691,7 @@
101913	101691	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101914	101692	}
101915	101693	// 1LLU
101916		- uint64_t return_to = 18446744073709545704LLU;
	101694	+ uint64_t return_to = 18446744073709545712LLU;
101917	101695	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101918	101696	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101919	101697	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101922,12 +101700,12 @@
101922	101700	state.addr = 839519719621918720LLU; // skipws____
101923	101701	break;
101924	101702	}
101925		- case 18446744073709545704LLU: // 99999998hm'''''''''''''''
	101703	+ case 18446744073709545712LLU: // 99999998hu'''''''''''''''
101926	101704	{
101927		- state.addr = 18446744073709545705LLU; // 99999998hn'''''''''''''''
	101705	+ state.addr = 18446744073709545713LLU; // 99999998hv'''''''''''''''
101928	101706	break;
101929	101707	}
101930		- case 18446744073709545705LLU: // 99999998hn'''''''''''''''
	101708	+ case 18446744073709545713LLU: // 99999998hv'''''''''''''''
101931	101709	{
101932	101710	{
101933	101711	uint64_t arg = 0LLU;

		@@ -101957,7 +101735,7 @@
101957	101735	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
101958	101736	}
101959	101737	// 5LLU
101960		- uint64_t return_to = 18446744073709545702LLU;
	101738	+ uint64_t return_to = 18446744073709545710LLU;
101961	101739	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
101962	101740	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
101963	101741	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -101966,12 +101744,12 @@
101966	101744	state.addr = 782701543567846272LLU; // parseress_
101967	101745	break;
101968	101746	}
101969		- case 18446744073709545702LLU: // 99999998hk'''''''''''''''
	101747	+ case 18446744073709545710LLU: // 99999998hs'''''''''''''''
101970	101748	{
101971		- state.addr = 18446744073709545703LLU; // 99999998hl'''''''''''''''
	101749	+ state.addr = 18446744073709545711LLU; // 99999998ht'''''''''''''''
101972	101750	break;
101973	101751	}
101974		- case 18446744073709545703LLU: // 99999998hl'''''''''''''''
	101752	+ case 18446744073709545711LLU: // 99999998ht'''''''''''''''
101975	101753	{
101976	101754	{
101977	101755	uint64_t arg = 0LLU;

		@@ -101982,24 +101760,24 @@
101982	101760	// variable u64 resscount_ goes out of scope
101983	101761	// emitted destructur for type u64
101984	101762	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resscount_ at 24
101985		- state.addr = 18446744073709545701LLU; // 99999998hj'''''''''''''''
	101763	+ state.addr = 18446744073709545709LLU; // 99999998hr'''''''''''''''
101986	101764	break;
101987	101765	}
101988		- case 18446744073709545701LLU: // 99999998hj'''''''''''''''
	101766	+ case 18446744073709545709LLU: // 99999998hr'''''''''''''''
101989	101767	{
101990	101768	// variable u64 returnbase goes out of scope
101991	101769	// emitted destructur for type u64
101992	101770	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference returnbase at 23
101993		- state.addr = 18446744073709545706LLU; // 99999998ho'''''''''''''''
	101771	+ state.addr = 18446744073709545714LLU; // 99999998hw'''''''''''''''
101994	101772	break;
101995	101773	}
101996		- case 18446744073709545706LLU: // 99999998ho'''''''''''''''
	101774	+ case 18446744073709545714LLU: // 99999998hw'''''''''''''''
101997	101775	{
101998	101776	list_reverse(heap.data, &/results___/*LOCAL_ACCESS(heap.data, 22LLU, 17LLU));
101999		- state.addr = 18446744073709545709LLU; // 99999998hr'''''''''''''''
	101777	+ state.addr = 18446744073709545717LLU; // 99999998hz'''''''''''''''
102000	101778	break;
102001	101779	}
102002		- case 18446744073709545709LLU: // 99999998hr'''''''''''''''
	101780	+ case 18446744073709545717LLU: // 99999998hz'''''''''''''''
102003	101781	{
102004	101782	{
102005	101783	uint64_t mainresult = heap.data[0].elem0;

		@@ -102009,7 +101787,7 @@
102009	101787	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102010	101788	}
102011	101789	// 1LLU
102012		- uint64_t return_to = 18446744073709545698LLU;
	101790	+ uint64_t return_to = 18446744073709545706LLU;
102013	101791	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102014	101792	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102015	101793	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102018,12 +101796,12 @@
102018	101796	state.addr = 839519719621918720LLU; // skipws____
102019	101797	break;
102020	101798	}
102021		- case 18446744073709545698LLU: // 99999998hg'''''''''''''''
	101799	+ case 18446744073709545706LLU: // 99999998ho'''''''''''''''
102022	101800	{
102023		- state.addr = 18446744073709545699LLU; // 99999998hh'''''''''''''''
	101801	+ state.addr = 18446744073709545707LLU; // 99999998hp'''''''''''''''
102024	101802	break;
102025	101803	}
102026		- case 18446744073709545699LLU: // 99999998hh'''''''''''''''
	101804	+ case 18446744073709545707LLU: // 99999998hp'''''''''''''''
102027	101805	{
102028	101806	/defbodysz_/LOCAL_ACCESS(heap.data, 22LLU, 14LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
102029	101807	/remainsize/LOCAL_ACCESS(heap.data, 22LLU, 15LLU) = /defbodysz_/LOCAL_ACCESS(heap.data, 22LLU, 14LLU);

		@@ -102036,7 +101814,7 @@
102036	101814	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102037	101815	}
102038	101816	// 1LLU
102039		- uint64_t return_to = 18446744073709545696LLU;
	101817	+ uint64_t return_to = 18446744073709545704LLU;
102040	101818	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102041	101819	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102042	101820	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102045,18 +101823,18 @@
102045	101823	state.addr = 839519719621918720LLU; // skipws____
102046	101824	break;
102047	101825	}
102048		- case 18446744073709545696LLU: // 99999998he'''''''''''''''
	101826	+ case 18446744073709545704LLU: // 99999998hm'''''''''''''''
102049	101827	{
102050		- state.addr = 18446744073709545697LLU; // 99999998hf'''''''''''''''
	101828	+ state.addr = 18446744073709545705LLU; // 99999998hn'''''''''''''''
102051	101829	break;
102052	101830	}
102053		- case 18446744073709545697LLU: // 99999998hf'''''''''''''''
	101831	+ case 18446744073709545705LLU: // 99999998hn'''''''''''''''
102054	101832	{
102055	101833	/remainheap/LOCAL_ACCESS(heap.data, 22LLU, 16LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 5LLU)));
102056		- state.addr = 18446744073709545700LLU; // 99999998hi'''''''''''''''
	101834	+ state.addr = 18446744073709545708LLU; // 99999998hq'''''''''''''''
102057	101835	break;
102058	101836	}
102059		- case 18446744073709545700LLU: // 99999998hi'''''''''''''''
	101837	+ case 18446744073709545708LLU: // 99999998hq'''''''''''''''
102060	101838	{
102061	101839	list_reverse(heap.data, &/signs_____/*LOCAL_ACCESS(heap.data, 22LLU, 21LLU));
102062	101840	{

		@@ -102072,10 +101850,10 @@
102072	101850	uint64_t arg = 0;
102073	101851	LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
102074	101852	}
102075		- state.addr = 18446744073709545694LLU; // 99999998hc'''''''''''''''
	101853	+ state.addr = 18446744073709545702LLU; // 99999998hk'''''''''''''''
102076	101854	break;
102077	101855	}
102078		- case 18446744073709545694LLU: // 99999998hc'''''''''''''''
	101856	+ case 18446744073709545702LLU: // 99999998hk'''''''''''''''
102079	101857	{
102080	101858	if(!*LOCAL_ACCESS(heap.data, 25LLU, 23LLU))
102081	101859	{

		@@ -102082,7 +101860,7 @@
102082	101860	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 25
102083	101861	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 24
102084	101862	{
102085		- state.addr = 18446744073709545693LLU; // 99999998hb'''''''''''''''
	101863	+ state.addr = 18446744073709545701LLU; // 99999998hj'''''''''''''''
102086	101864	break;
102087	101865	}
102088	101866	}

		@@ -102115,7 +101893,7 @@
102115	101893	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102116	101894	}
102117	101895	// 2LLU
102118		- uint64_t return_to = 18446744073709545691LLU;
	101896	+ uint64_t return_to = 18446744073709545699LLU;
102119	101897	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102120	101898	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102121	101899	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102124,12 +101902,12 @@
102124	101902	state.addr = 861504776686223360LLU; // typecopy__
102125	101903	break;
102126	101904	}
102127		- case 18446744073709545691LLU: // 99999998h$'''''''''''''''
	101905	+ case 18446744073709545699LLU: // 99999998hh'''''''''''''''
102128	101906	{
102129		- state.addr = 18446744073709545692LLU; // 99999998ha'''''''''''''''
	101907	+ state.addr = 18446744073709545700LLU; // 99999998hi'''''''''''''''
102130	101908	break;
102131	101909	}
102132		- case 18446744073709545692LLU: // 99999998ha'''''''''''''''
	101910	+ case 18446744073709545700LLU: // 99999998hi'''''''''''''''
102133	101911	{
102134	101912	{
102135	101913	uint64_t arg = /sign______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 24LLU), 1LLU));

		@@ -102154,7 +101932,7 @@
102154	101932	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102155	101933	}
102156	101934	// 2LLU
102157		- uint64_t return_to = 18446744073709545689LLU;
	101935	+ uint64_t return_to = 18446744073709545697LLU;
102158	101936	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102159	101937	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102160	101938	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102163,12 +101941,12 @@
102163	101941	state.addr = 552446636209866541LLU; // copylinear
102164	101942	break;
102165	101943	}
102166		- case 18446744073709545689LLU: // 99999998hY'''''''''''''''
	101944	+ case 18446744073709545697LLU: // 99999998hf'''''''''''''''
102167	101945	{
102168		- state.addr = 18446744073709545690LLU; // 99999998hZ'''''''''''''''
	101946	+ state.addr = 18446744073709545698LLU; // 99999998hg'''''''''''''''
102169	101947	break;
102170	101948	}
102171		- case 18446744073709545690LLU: // 99999998hZ'''''''''''''''
	101949	+ case 18446744073709545698LLU: // 99999998hg'''''''''''''''
102172	101950	{
102173	101951	{
102174	101952	uint64_t arg = 1LLU;

		@@ -102184,10 +101962,10 @@
102184	101962	;
102185	101963	LOCAL_PUSH_MOVE(&heap, 31, &(heap.data[0].elem1)/address of current closure/, &arg);
102186	101964	}
102187		- state.addr = !list_push_move(&heap, &/par_______/LOCAL_ACCESS(heap.data, 32LLU, 31LLU), &/defpars___/LOCAL_ACCESS(heap.data, 32LLU, 18LLU), 6) ? 18446744073709545688LLU : 18446744073709545687LLU;
	101965	+ state.addr = !list_push_move(&heap, &/par_______/LOCAL_ACCESS(heap.data, 32LLU, 31LLU), &/defpars___/LOCAL_ACCESS(heap.data, 32LLU, 18LLU), 6) ? 18446744073709545696LLU : 18446744073709545695LLU;
102188	101966	break;
102189	101967	}
102190		- case 18446744073709545688LLU: // 99999998hX'''''''''''''''
	101968	+ case 18446744073709545696LLU: // 99999998he'''''''''''''''
102191	101969	{
102192	101970	{
102193	101971	uint64_t arg = *LOCAL_ACCESS(heap.data, 32LLU, 31LLU);

		@@ -102201,7 +101979,7 @@
102201	101979	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102202	101980	}
102203	101981	// 1LLU
102204		- uint64_t return_to = 18446744073709545685LLU;
	101982	+ uint64_t return_to = 18446744073709545693LLU;
102205	101983	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102206	101984	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102207	101985	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102210,12 +101988,12 @@
102210	101988	state.addr = 819847183515949359LLU; // reportinit
102211	101989	break;
102212	101990	}
102213		- case 18446744073709545685LLU: // 99999998hU'''''''''''''''
	101991	+ case 18446744073709545693LLU: // 99999998hb'''''''''''''''
102214	101992	{
102215		- state.addr = 18446744073709545686LLU; // 99999998hV'''''''''''''''
	101993	+ state.addr = 18446744073709545694LLU; // 99999998hc'''''''''''''''
102216	101994	break;
102217	101995	}
102218		- case 18446744073709545686LLU: // 99999998hV'''''''''''''''
	101996	+ case 18446744073709545694LLU: // 99999998hc'''''''''''''''
102219	101997	{
102220	101998	fprintf(stderr, "%s", "parsing definition, ");
102221	101999	{

		@@ -102232,7 +102010,7 @@
102232	102010	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102233	102011	}
102234	102012	// 1LLU
102235		- uint64_t return_to = 18446744073709545684LLU;
	102013	+ uint64_t return_to = 18446744073709545692LLU;
102236	102014	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102237	102015	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102238	102016	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102241,20 +102019,20 @@
102241	102019	state.addr = 782700512565790404LLU; // pardef__$D
102242	102020	break;
102243	102021	}
102244		- case 18446744073709545684LLU: // 99999998hT'''''''''''''''
	102022	+ case 18446744073709545692LLU: // 99999998ha'''''''''''''''
102245	102023	{
102246	102024	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 33
102247	102025	heap.availilable_size_for_dynamic_objects += 0LLU;
102248	102026	heap.availilable_size_for_dynamic_objects += 0LLU;
102249		- state.addr = 18446744073709545683LLU; // 99999998hS'''''''''''''''
	102027	+ state.addr = 18446744073709545691LLU; // 99999998h$'''''''''''''''
102250	102028	break;
102251	102029	}
102252		- case 18446744073709545687LLU: // 99999998hW'''''''''''''''
	102030	+ case 18446744073709545695LLU: // 99999998hd'''''''''''''''
102253	102031	{
102254		- state.addr = 18446744073709545683LLU; // 99999998hS'''''''''''''''
	102032	+ state.addr = 18446744073709545691LLU; // 99999998h$'''''''''''''''
102255	102033	break;
102256	102034	}
102257		- case 18446744073709545683LLU: // 99999998hS'''''''''''''''
	102035	+ case 18446744073709545691LLU: // 99999998h$'''''''''''''''
102258	102036	{
102259	102037	// variable pardef____ par_______ goes out of scope
102260	102038	// (uninitialized -> no destructor-call)

		@@ -102279,10 +102057,10 @@
102279	102057	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parid_____ at 26
102280	102058	// parameter-reference signdef___ sign______ goes out of scope
102281	102059	// parameter list<signdef___> signs_____ goes out of scope
102282		- state.addr = 18446744073709545694LLU; // 99999998hc'''''''''''''''
	102060	+ state.addr = 18446744073709545702LLU; // 99999998hk'''''''''''''''
102283	102061	break;
102284	102062	}
102285		- case 18446744073709545693LLU: // 99999998hb'''''''''''''''
	102063	+ case 18446744073709545701LLU: // 99999998hj'''''''''''''''
102286	102064	{
102287	102065	{
102288	102066	uint64_t arg = 0LLU;

		@@ -102293,18 +102071,18 @@
102293	102071	// variable u64 argscount_ goes out of scope
102294	102072	// emitted destructur for type u64
102295	102073	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference argscount_ at 24
102296		- state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
	102074	+ state.addr = 18446744073709545690LLU; // 99999998hZ'''''''''''''''
102297	102075	break;
102298	102076	}
102299		- case 18446744073709545682LLU: // 99999998hR'''''''''''''''
	102077	+ case 18446744073709545690LLU: // 99999998hZ'''''''''''''''
102300	102078	{
102301	102079	// variable u64 returnbase goes out of scope
102302	102080	// emitted destructur for type u64
102303	102081	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference returnbase at 23
102304		- state.addr = 18446744073709545695LLU; // 99999998hd'''''''''''''''
	102082	+ state.addr = 18446744073709545703LLU; // 99999998hl'''''''''''''''
102305	102083	break;
102306	102084	}
102307		- case 18446744073709545695LLU: // 99999998hd'''''''''''''''
	102085	+ case 18446744073709545703LLU: // 99999998hl'''''''''''''''
102308	102086	{
102309	102087	{
102310	102088	uint64_t arg = 0LLU;

		@@ -102322,7 +102100,7 @@
102322	102100	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102323	102101	}
102324	102102	// 1LLU
102325		- uint64_t return_to = 18446744073709545679LLU;
	102103	+ uint64_t return_to = 18446744073709545687LLU;
102326	102104	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102327	102105	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102328	102106	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102331,12 +102109,12 @@
102331	102109	state.addr = 839519719621918720LLU; // skipws____
102332	102110	break;
102333	102111	}
102334		- case 18446744073709545679LLU: // 99999998hO'''''''''''''''
	102112	+ case 18446744073709545687LLU: // 99999998hW'''''''''''''''
102335	102113	{
102336		- state.addr = 18446744073709545680LLU; // 99999998hP'''''''''''''''
	102114	+ state.addr = 18446744073709545688LLU; // 99999998hX'''''''''''''''
102337	102115	break;
102338	102116	}
102339		- case 18446744073709545680LLU: // 99999998hP'''''''''''''''
	102117	+ case 18446744073709545688LLU: // 99999998hX'''''''''''''''
102340	102118	{
102341	102119	{
102342	102120	uint64_t mainresult = heap.data[0].elem0;

		@@ -102354,7 +102132,7 @@
102354	102132	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102355	102133	}
102356	102134	// 3LLU
102357		- uint64_t return_to = 18446744073709545677LLU;
	102135	+ uint64_t return_to = 18446744073709545685LLU;
102358	102136	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102359	102137	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102360	102138	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102363,38 +102141,38 @@
102363	102141	state.addr = 728666047794575267LLU; // matchoptch
102364	102142	break;
102365	102143	}
102366		- case 18446744073709545677LLU: // 99999998hM'''''''''''''''
	102144	+ case 18446744073709545685LLU: // 99999998hU'''''''''''''''
102367	102145	{
102368		- state.addr = 18446744073709545678LLU; // 99999998hN'''''''''''''''
	102146	+ state.addr = 18446744073709545686LLU; // 99999998hV'''''''''''''''
102369	102147	break;
102370	102148	}
102371		- case 18446744073709545678LLU: // 99999998hN'''''''''''''''
	102149	+ case 18446744073709545686LLU: // 99999998hV'''''''''''''''
102372	102150	{
102373		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545676LLU : 18446744073709545675LLU;
	102151	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545684LLU : 18446744073709545683LLU;
102374	102152	break;
102375	102153	}
102376		- case 18446744073709545676LLU: // 99999998hL'''''''''''''''
	102154	+ case 18446744073709545684LLU: // 99999998hT'''''''''''''''
102377	102155	{
102378	102156	/defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0LLU;
102379	102157
102380	102158	heap.availilable_size_for_dynamic_objects += 0LLU;
102381	102159	heap.availilable_size_for_dynamic_objects += 0LLU;
102382		- state.addr = 18446744073709545674LLU; // 99999998hJ'''''''''''''''
	102160	+ state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
102383	102161	break;
102384	102162	}
102385		- case 18446744073709545675LLU: // 99999998hK'''''''''''''''
	102163	+ case 18446744073709545683LLU: // 99999998hS'''''''''''''''
102386	102164	{
102387	102165	/defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 1LLU;
102388	102166
102389		- state.addr = 18446744073709545674LLU; // 99999998hJ'''''''''''''''
	102167	+ state.addr = 18446744073709545682LLU; // 99999998hR'''''''''''''''
102390	102168	break;
102391	102169	}
102392		- case 18446744073709545674LLU: // 99999998hJ'''''''''''''''
	102170	+ case 18446744073709545682LLU: // 99999998hR'''''''''''''''
102393	102171	{
102394		- state.addr = 18446744073709545681LLU; // 99999998hQ'''''''''''''''
	102172	+ state.addr = 18446744073709545689LLU; // 99999998hY'''''''''''''''
102395	102173	break;
102396	102174	}
102397		- case 18446744073709545681LLU: // 99999998hQ'''''''''''''''
	102175	+ case 18446744073709545689LLU: // 99999998hY'''''''''''''''
102398	102176	{
102399	102177	{
102400	102178	uint64_t arg = 0LLU;

		@@ -102444,7 +102222,7 @@
102444	102222	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102445	102223	}
102446	102224	// 10LLU
102447		- uint64_t return_to = 18446744073709545671LLU;
	102225	+ uint64_t return_to = 18446744073709545679LLU;
102448	102226	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102449	102227	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102450	102228	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102453,12 +102231,12 @@
102453	102231	state.addr = 728626598349373440LLU; // makedef___
102454	102232	break;
102455	102233	}
102456		- case 18446744073709545671LLU: // 99999998hG'''''''''''''''
	102234	+ case 18446744073709545679LLU: // 99999998hO'''''''''''''''
102457	102235	{
102458		- state.addr = 18446744073709545672LLU; // 99999998hH'''''''''''''''
	102236	+ state.addr = 18446744073709545680LLU; // 99999998hP'''''''''''''''
102459	102237	break;
102460	102238	}
102461		- case 18446744073709545672LLU: // 99999998hH'''''''''''''''
	102239	+ case 18446744073709545680LLU: // 99999998hP'''''''''''''''
102462	102240	{
102463	102241	{
102464	102242	uint64_t arg = 1LLU;

		@@ -102472,10 +102250,10 @@
102472	102250	uint64_t arg = 0;
102473	102251	LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
102474	102252	}
102475		- state.addr = 18446744073709545670LLU; // 99999998hF'''''''''''''''
	102253	+ state.addr = 18446744073709545678LLU; // 99999998hN'''''''''''''''
102476	102254	break;
102477	102255	}
102478		- case 18446744073709545670LLU: // 99999998hF'''''''''''''''
	102256	+ case 18446744073709545678LLU: // 99999998hN'''''''''''''''
102479	102257	{
102480	102258	if(!*LOCAL_ACCESS(heap.data, 27LLU, 25LLU))
102481	102259	{

		@@ -102482,16 +102260,16 @@
102482	102260	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
102483	102261	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 26
102484	102262	{
102485		- state.addr = 18446744073709545669LLU; // 99999998hE'''''''''''''''
	102263	+ state.addr = 18446744073709545677LLU; // 99999998hM'''''''''''''''
102486	102264	break;
102487	102265	}
102488	102266	}
102489	102267	/direct/LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = (LOCAL_ACCESS(heap.data, 27LLU, 25LLU) << 1) + 1LLU;
102490	102268	LOCAL_ACCESS(heap.data, 27LLU, 25LLU) = heap.data[LOCAL_ACCESS(heap.data, 27LLU, 25LLU)].elem0;
102491		- state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545668LLU : 18446744073709545667LLU;
	102269	+ state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545676LLU : 18446744073709545675LLU;
102492	102270	break;
102493	102271	}
102494		- case 18446744073709545668LLU: // 99999998hD'''''''''''''''
	102272	+ case 18446744073709545676LLU: // 99999998hL'''''''''''''''
102495	102273	{
102496	102274	{
102497	102275	uint64_t arg = 0LLU;

		@@ -102498,10 +102276,10 @@
102498	102276	LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
102499	102277	}
102500	102278	/match_____/LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = /id________/LOCAL_ACCESS(heap.data, 28LLU, 7LLU) == /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 0LLU));
102501		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545666LLU : 18446744073709545665LLU;
	102279	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545674LLU : 18446744073709545673LLU;
102502	102280	break;
102503	102281	}
102504		- case 18446744073709545666LLU: // 99999998hB'''''''''''''''
	102282	+ case 18446744073709545674LLU: // 99999998hJ'''''''''''''''
102505	102283	{
102506	102284	/fresh_____/*LOCAL_ACCESS(heap.data, 28LLU, 24LLU) = 0LLU;
102507	102285

		@@ -102521,7 +102299,7 @@
102521	102299	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102522	102300	}
102523	102301	// 3LLU
102524		- uint64_t return_to = 18446744073709545663LLU;
	102302	+ uint64_t return_to = 18446744073709545671LLU;
102525	102303	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102526	102304	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102527	102305	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102530,22 +102308,22 @@
102530	102308	state.addr = 589059069805989888LLU; // equfndef__
102531	102309	break;
102532	102310	}
102533		- case 18446744073709545663LLU: // 99999998g9'''''''''''''''
	102311	+ case 18446744073709545671LLU: // 99999998hG'''''''''''''''
102534	102312	{
102535		- state.addr = 18446744073709545664LLU; // 99999998h_'''''''''''''''
	102313	+ state.addr = 18446744073709545672LLU; // 99999998hH'''''''''''''''
102536	102314	break;
102537	102315	}
102538		- case 18446744073709545664LLU: // 99999998h_'''''''''''''''
	102316	+ case 18446744073709545672LLU: // 99999998hH'''''''''''''''
102539	102317	{
102540		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545662LLU : 18446744073709545661LLU;
	102318	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545670LLU : 18446744073709545669LLU;
102541	102319	break;
102542	102320	}
102543		- case 18446744073709545662LLU: // 99999998g8'''''''''''''''
	102321	+ case 18446744073709545670LLU: // 99999998hF'''''''''''''''
102544	102322	{
102545		- state.addr = /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545660LLU : 18446744073709545659LLU;
	102323	+ state.addr = /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545668LLU : 18446744073709545667LLU;
102546	102324	break;
102547	102325	}
102548		- case 18446744073709545660LLU: // 99999998g6'''''''''''''''
	102326	+ case 18446744073709545668LLU: // 99999998hD'''''''''''''''
102549	102327	{
102550	102328	fprintf(stderr, "%s", "re-definition of ");
102551	102329	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));

		@@ -102555,43 +102333,43 @@
102555	102333	}
102556	102334	heap.availilable_size_for_dynamic_objects += 0LLU;
102557	102335	heap.availilable_size_for_dynamic_objects += 0LLU;
102558		- state.addr = 18446744073709545658LLU; // 99999998g4'''''''''''''''
	102336	+ state.addr = 18446744073709545666LLU; // 99999998hB'''''''''''''''
102559	102337	break;
102560	102338	}
102561		- case 18446744073709545659LLU: // 99999998g5'''''''''''''''
	102339	+ case 18446744073709545667LLU: // 99999998hC'''''''''''''''
102562	102340	{
102563		- state.addr = /current___/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545657LLU : 18446744073709545656LLU;
	102341	+ state.addr = /current___/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545665LLU : 18446744073709545664LLU;
102564	102342	break;
102565	102343	}
102566		- case 18446744073709545657LLU: // 99999998g3'''''''''''''''
	102344	+ case 18446744073709545665LLU: // 99999998hA'''''''''''''''
102567	102345	{
102568	102346	swap(&/current___/LOCAL_ACCESS(heap.data, 28LLU, 23LLU), &/previous__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU)));
102569	102347	heap.availilable_size_for_dynamic_objects += 0LLU;
102570	102348	heap.availilable_size_for_dynamic_objects += 0LLU;
102571		- state.addr = 18446744073709545655LLU; // 99999998g1'''''''''''''''
	102349	+ state.addr = 18446744073709545663LLU; // 99999998g9'''''''''''''''
102572	102350	break;
102573	102351	}
102574		- case 18446744073709545656LLU: // 99999998g2'''''''''''''''
	102352	+ case 18446744073709545664LLU: // 99999998h_'''''''''''''''
102575	102353	{
102576	102354	fprintf(stderr, "%s", "WARNING: superfluous re-declaration of ");
102577	102355	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
102578	102356	fprintf(stderr, "%s", "\n");
102579		- state.addr = 18446744073709545655LLU; // 99999998g1'''''''''''''''
	102357	+ state.addr = 18446744073709545663LLU; // 99999998g9'''''''''''''''
102580	102358	break;
102581	102359	}
102582		- case 18446744073709545655LLU: // 99999998g1'''''''''''''''
	102360	+ case 18446744073709545663LLU: // 99999998g9'''''''''''''''
102583	102361	{
102584		- state.addr = 18446744073709545658LLU; // 99999998g4'''''''''''''''
	102362	+ state.addr = 18446744073709545666LLU; // 99999998hB'''''''''''''''
102585	102363	break;
102586	102364	}
102587		- case 18446744073709545658LLU: // 99999998g4'''''''''''''''
	102365	+ case 18446744073709545666LLU: // 99999998hB'''''''''''''''
102588	102366	{
102589	102367	heap.availilable_size_for_dynamic_objects += 0LLU;
102590	102368	heap.availilable_size_for_dynamic_objects += 0LLU;
102591		- state.addr = 18446744073709545654LLU; // 99999998g0'''''''''''''''
	102369	+ state.addr = 18446744073709545662LLU; // 99999998g8'''''''''''''''
102592	102370	break;
102593	102371	}
102594		- case 18446744073709545661LLU: // 99999998g7'''''''''''''''
	102372	+ case 18446744073709545669LLU: // 99999998hE'''''''''''''''
102595	102373	{
102596	102374	fprintf(stderr, "%s", "re-definition of ");
102597	102375	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));

		@@ -102600,35 +102378,35 @@
102600	102378	fprintf(stderr, "%s\n", "");
102601	102379	exit(-1);
102602	102380	}
102603		- state.addr = 18446744073709545654LLU; // 99999998g0'''''''''''''''
	102381	+ state.addr = 18446744073709545662LLU; // 99999998g8'''''''''''''''
102604	102382	break;
102605	102383	}
102606		- case 18446744073709545654LLU: // 99999998g0'''''''''''''''
	102384	+ case 18446744073709545662LLU: // 99999998g8'''''''''''''''
102607	102385	{
102608		- state.addr = 18446744073709545665LLU; // 99999998hA'''''''''''''''
	102386	+ state.addr = 18446744073709545673LLU; // 99999998hI'''''''''''''''
102609	102387	break;
102610	102388	}
102611		- case 18446744073709545665LLU: // 99999998hA'''''''''''''''
	102389	+ case 18446744073709545673LLU: // 99999998hI'''''''''''''''
102612	102390	{
102613	102391	// variable u64 match_____ goes out of scope
102614	102392	// emitted destructur for type u64
102615	102393	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 28
102616		- state.addr = 18446744073709545667LLU; // 99999998hC'''''''''''''''
	102394	+ state.addr = 18446744073709545675LLU; // 99999998hK'''''''''''''''
102617	102395	break;
102618	102396	}
102619		- case 18446744073709545667LLU: // 99999998hC'''''''''''''''
	102397	+ case 18446744073709545675LLU: // 99999998hK'''''''''''''''
102620	102398	{
102621	102399	// parameter-reference defidfn___ previous__ goes out of scope
102622	102400	// parameter-reference list<defidfn___> fndefs____ goes out of scope
102623		- state.addr = 18446744073709545670LLU; // 99999998hF'''''''''''''''
	102401	+ state.addr = 18446744073709545678LLU; // 99999998hN'''''''''''''''
102624	102402	break;
102625	102403	}
102626		- case 18446744073709545669LLU: // 99999998hE'''''''''''''''
	102404	+ case 18446744073709545677LLU: // 99999998hM'''''''''''''''
102627	102405	{
102628		- state.addr = !list_push_move(&heap, &/current___/LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/fndefs____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 9) ? 18446744073709545652LLU : 18446744073709545651LLU;
	102406	+ state.addr = !list_push_move(&heap, &/current___/LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/fndefs____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 9) ? 18446744073709545660LLU : 18446744073709545659LLU;
102629	102407	break;
102630	102408	}
102631		- case 18446744073709545652LLU: // 99999998gy'''''''''''''''
	102409	+ case 18446744073709545660LLU: // 99999998g6'''''''''''''''
102632	102410	{
102633	102411	{
102634	102412	uint64_t arg = *LOCAL_ACCESS(heap.data, 25LLU, 23LLU);

		@@ -102651,7 +102429,7 @@
102651	102429	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102652	102430	}
102653	102431	// 1LLU
102654		- uint64_t return_to = 18446744073709545650LLU;
	102432	+ uint64_t return_to = 18446744073709545658LLU;
102655	102433	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102656	102434	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102657	102435	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102660,32 +102438,32 @@
102660	102438	state.addr = 567601196335105732LLU; // defidfn_$D
102661	102439	break;
102662	102440	}
102663		- case 18446744073709545650LLU: // 99999998gw'''''''''''''''
	102441	+ case 18446744073709545658LLU: // 99999998g4'''''''''''''''
102664	102442	{
102665	102443	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference current___ at 26
102666	102444	heap.availilable_size_for_dynamic_objects += 0LLU;
102667	102445	heap.availilable_size_for_dynamic_objects += 0LLU;
102668		- state.addr = 18446744073709545649LLU; // 99999998gv'''''''''''''''
	102446	+ state.addr = 18446744073709545657LLU; // 99999998g3'''''''''''''''
102669	102447	break;
102670	102448	}
102671		- case 18446744073709545651LLU: // 99999998gx'''''''''''''''
	102449	+ case 18446744073709545659LLU: // 99999998g5'''''''''''''''
102672	102450	{
102673		- state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545648LLU : 18446744073709545647LLU;
	102451	+ state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545656LLU : 18446744073709545655LLU;
102674	102452	break;
102675	102453	}
102676		- case 18446744073709545648LLU: // 99999998gu'''''''''''''''
	102454	+ case 18446744073709545656LLU: // 99999998g2'''''''''''''''
102677	102455	{
102678	102456	heap.availilable_size_for_dynamic_objects += 0LLU;
102679	102457	heap.availilable_size_for_dynamic_objects += 0LLU;
102680		- state.addr = 18446744073709545646LLU; // 99999998gs'''''''''''''''
	102458	+ state.addr = 18446744073709545654LLU; // 99999998g0'''''''''''''''
102681	102459	break;
102682	102460	}
102683		- case 18446744073709545647LLU: // 99999998gt'''''''''''''''
	102461	+ case 18446744073709545655LLU: // 99999998g1'''''''''''''''
102684	102462	{
102685		- state.addr = /fndefs____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545645LLU : 18446744073709545644LLU;
	102463	+ state.addr = /fndefs____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545653LLU : 18446744073709545652LLU;
102686	102464	break;
102687	102465	}
102688		- case 18446744073709545645LLU: // 99999998gr'''''''''''''''
	102466	+ case 18446744073709545653LLU: // 99999998gz'''''''''''''''
102689	102467	{
102690	102468	{
102691	102469	uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU))/list/, 9);

		@@ -102701,7 +102479,7 @@
102701	102479	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102702	102480	}
102703	102481	// 1LLU
102704		- uint64_t return_to = 18446744073709545643LLU;
	102482	+ uint64_t return_to = 18446744073709545651LLU;
102705	102483	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102706	102484	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102707	102485	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102710,39 +102488,39 @@
102710	102488	state.addr = 567601196335105732LLU; // defidfn_$D
102711	102489	break;
102712	102490	}
102713		- case 18446744073709545643LLU: // 99999998gp'''''''''''''''
	102491	+ case 18446744073709545651LLU: // 99999998gx'''''''''''''''
102714	102492	{
102715	102493	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dummy_____ at 26
102716	102494	heap.availilable_size_for_dynamic_objects += 0LLU;
102717	102495	heap.availilable_size_for_dynamic_objects += 0LLU;
102718		- state.addr = 18446744073709545642LLU; // 99999998go'''''''''''''''
	102496	+ state.addr = 18446744073709545650LLU; // 99999998gw'''''''''''''''
102719	102497	break;
102720	102498	}
102721		- case 18446744073709545644LLU: // 99999998gq'''''''''''''''
	102499	+ case 18446744073709545652LLU: // 99999998gy'''''''''''''''
102722	102500	{
102723	102501	{
102724	102502	fprintf(stderr, "%s\n", "INTERNAL COMPILER ERROR in clumsy decl-replace-code: this should never happen!");
102725	102503	exit(-1);
102726	102504	}
102727		- state.addr = 18446744073709545642LLU; // 99999998go'''''''''''''''
	102505	+ state.addr = 18446744073709545650LLU; // 99999998gw'''''''''''''''
102728	102506	break;
102729	102507	}
102730		- case 18446744073709545642LLU: // 99999998go'''''''''''''''
	102508	+ case 18446744073709545650LLU: // 99999998gw'''''''''''''''
102731	102509	{
102732		- state.addr = 18446744073709545646LLU; // 99999998gs'''''''''''''''
	102510	+ state.addr = 18446744073709545654LLU; // 99999998g0'''''''''''''''
102733	102511	break;
102734	102512	}
102735		- case 18446744073709545646LLU: // 99999998gs'''''''''''''''
	102513	+ case 18446744073709545654LLU: // 99999998g0'''''''''''''''
102736	102514	{
102737		- state.addr = 18446744073709545649LLU; // 99999998gv'''''''''''''''
	102515	+ state.addr = 18446744073709545657LLU; // 99999998g3'''''''''''''''
102738	102516	break;
102739	102517	}
102740		- case 18446744073709545649LLU: // 99999998gv'''''''''''''''
	102518	+ case 18446744073709545657LLU: // 99999998g3'''''''''''''''
102741	102519	{
102742		- state.addr = 18446744073709545653LLU; // 99999998gz'''''''''''''''
	102520	+ state.addr = 18446744073709545661LLU; // 99999998g7'''''''''''''''
102743	102521	break;
102744	102522	}
102745		- case 18446744073709545653LLU: // 99999998gz'''''''''''''''
	102523	+ case 18446744073709545661LLU: // 99999998g7'''''''''''''''
102746	102524	{
102747	102525	// variable u64 fresh_____ goes out of scope
102748	102526	// emitted destructur for type u64

		@@ -102750,15 +102528,15 @@
102750	102528	// variable defidfn___ current___ goes out of scope
102751	102529	// (uninitialized -> no destructor-call)
102752	102530	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference current___ at 24
102753		- state.addr = 18446744073709545673LLU; // 99999998hI'''''''''''''''
	102531	+ state.addr = 18446744073709545681LLU; // 99999998hQ'''''''''''''''
102754	102532	break;
102755	102533	}
102756		- case 18446744073709545673LLU: // 99999998hI'''''''''''''''
	102534	+ case 18446744073709545681LLU: // 99999998hQ'''''''''''''''
102757	102535	{
102758		- state.addr = /defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545640LLU : 18446744073709545639LLU;
	102536	+ state.addr = /defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545648LLU : 18446744073709545647LLU;
102759	102537	break;
102760	102538	}
102761		- case 18446744073709545640LLU: // 99999998gm'''''''''''''''
	102539	+ case 18446744073709545648LLU: // 99999998gu'''''''''''''''
102762	102540	{
102763	102541	list_reverse(heap.data, &/results___/*LOCAL_ACCESS(heap.data, 23LLU, 17LLU));
102764	102542	{

		@@ -102771,15 +102549,15 @@
102771	102549	fprintf(stderr, "match failed at char %c\n", (char)124LLU);
102772	102550	exit(-1);
102773	102551	}
102774		- state.addr = 18446744073709545638LLU; // 99999998gk'''''''''''''''
	102552	+ state.addr = 18446744073709545646LLU; // 99999998gs'''''''''''''''
102775	102553	break;
102776	102554	}
102777		- case 18446744073709545638LLU: // 99999998gk'''''''''''''''
	102555	+ case 18446744073709545646LLU: // 99999998gs'''''''''''''''
102778	102556	{
102779	102557	access_heap(heap.data, LOCAL_ACCESS(heap.data, 24LLU, 5LLU)) = (uint64_t)getchar();
102780	102558	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 24LLU, 5LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 24LLU, 5LLU)) > 255)
102781	102559	{
102782		- state.addr = 18446744073709545637LLU; // 99999998gj'''''''''''''''
	102560	+ state.addr = 18446744073709545645LLU; // 99999998gr'''''''''''''''
102783	102561	break;
102784	102562	}
102785	102563	{

		@@ -102790,7 +102568,7 @@
102790	102568	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102791	102569	}
102792	102570	// 1LLU
102793		- uint64_t return_to = 18446744073709545634LLU;
	102571	+ uint64_t return_to = 18446744073709545642LLU;
102794	102572	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102795	102573	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102796	102574	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102799,12 +102577,12 @@
102799	102577	state.addr = 839519719621918720LLU; // skipws____
102800	102578	break;
102801	102579	}
102802		- case 18446744073709545634LLU: // 99999998gg'''''''''''''''
	102580	+ case 18446744073709545642LLU: // 99999998go'''''''''''''''
102803	102581	{
102804		- state.addr = 18446744073709545635LLU; // 99999998gh'''''''''''''''
	102582	+ state.addr = 18446744073709545643LLU; // 99999998gp'''''''''''''''
102805	102583	break;
102806	102584	}
102807		- case 18446744073709545635LLU: // 99999998gh'''''''''''''''
	102585	+ case 18446744073709545643LLU: // 99999998gp'''''''''''''''
102808	102586	{
102809	102587	{
102810	102588	uint64_t arg = 0LLU;

		@@ -102812,10 +102590,10 @@
102812	102590	}
102813	102591	/repeatid__/LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 5LLU)));
102814	102592	/matchsym__/LOCAL_ACCESS(heap.data, 25LLU, 20LLU) = /repeatid__/LOCAL_ACCESS(heap.data, 25LLU, 24LLU) != /id________/*LOCAL_ACCESS(heap.data, 25LLU, 7LLU);
102815		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU) ? 18446744073709545633LLU : 18446744073709545632LLU;
	102593	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 25LLU, 20LLU) ? 18446744073709545641LLU : 18446744073709545640LLU;
102816	102594	break;
102817	102595	}
102818		- case 18446744073709545633LLU: // 99999998gf'''''''''''''''
	102596	+ case 18446744073709545641LLU: // 99999998gn'''''''''''''''
102819	102597	{
102820	102598	{
102821	102599	uint64_t mainresult = heap.data[0].elem0;

		@@ -102825,7 +102603,7 @@
102825	102603	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102826	102604	}
102827	102605	// 1LLU
102828		- uint64_t return_to = 18446744073709545630LLU;
	102606	+ uint64_t return_to = 18446744073709545638LLU;
102829	102607	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102830	102608	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102831	102609	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102834,12 +102612,12 @@
102834	102612	state.addr = 819847183515949359LLU; // reportinit
102835	102613	break;
102836	102614	}
102837		- case 18446744073709545630LLU: // 99999998gc'''''''''''''''
	102615	+ case 18446744073709545638LLU: // 99999998gk'''''''''''''''
102838	102616	{
102839		- state.addr = 18446744073709545631LLU; // 99999998gd'''''''''''''''
	102617	+ state.addr = 18446744073709545639LLU; // 99999998gl'''''''''''''''
102840	102618	break;
102841	102619	}
102842		- case 18446744073709545631LLU: // 99999998gd'''''''''''''''
	102620	+ case 18446744073709545639LLU: // 99999998gl'''''''''''''''
102843	102621	{
102844	102622	fprintf(stderr, "%s", "pattern-matching definition-case must have same name as declaration - expected ");
102845	102623	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 25LLU, 7LLU));

		@@ -102849,18 +102627,18 @@
102849	102627	fprintf(stderr, "%s\n", "");
102850	102628	exit(-1);
102851	102629	}
102852		- state.addr = 18446744073709545632LLU; // 99999998ge'''''''''''''''
	102630	+ state.addr = 18446744073709545640LLU; // 99999998gm'''''''''''''''
102853	102631	break;
102854	102632	}
102855		- case 18446744073709545632LLU: // 99999998ge'''''''''''''''
	102633	+ case 18446744073709545640LLU: // 99999998gm'''''''''''''''
102856	102634	{
102857	102635	// variable u64 repeatid__ goes out of scope
102858	102636	// emitted destructur for type u64
102859	102637	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference repeatid__ at 25
102860		- state.addr = 18446744073709545636LLU; // 99999998gi'''''''''''''''
	102638	+ state.addr = 18446744073709545644LLU; // 99999998gq'''''''''''''''
102861	102639	break;
102862	102640	}
102863		- case 18446744073709545636LLU: // 99999998gi'''''''''''''''
	102641	+ case 18446744073709545644LLU: // 99999998gq'''''''''''''''
102864	102642	{
102865	102643	{
102866	102644	uint64_t arg = 1LLU;

		@@ -102946,7 +102724,7 @@
102946	102724	LOCAL_PUSH_MOVE(&heap, 18LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102947	102725	}
102948	102726	// 19LLU
102949		- uint64_t return_to = 18446744073709545628LLU;
	102727	+ uint64_t return_to = 18446744073709545636LLU;
102950	102728	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102951	102729	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 19LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102952	102730	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102955,25 +102733,25 @@
102955	102733	state.addr = 288592327072833536LLU; // PARSEDEF__
102956	102734	break;
102957	102735	}
102958		- case 18446744073709545628LLU: // 99999998ga'''''''''''''''
	102736	+ case 18446744073709545636LLU: // 99999998gi'''''''''''''''
102959	102737	{
102960		- state.addr = 18446744073709545629LLU; // 99999998gb'''''''''''''''
	102738	+ state.addr = 18446744073709545637LLU; // 99999998gj'''''''''''''''
102961	102739	break;
102962	102740	}
102963		- case 18446744073709545629LLU: // 99999998gb'''''''''''''''
	102741	+ case 18446744073709545637LLU: // 99999998gj'''''''''''''''
102964	102742	{
102965		- state.addr = /simple____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545627LLU : 18446744073709545626LLU;
	102743	+ state.addr = /simple____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545635LLU : 18446744073709545634LLU;
102966	102744	break;
102967	102745	}
102968		- case 18446744073709545627LLU: // 99999998g$'''''''''''''''
	102746	+ case 18446744073709545635LLU: // 99999998gh'''''''''''''''
102969	102747	{
102970	102748	ungetc(0, stdin);
102971	102749	heap.availilable_size_for_dynamic_objects += 0LLU;
102972	102750	heap.availilable_size_for_dynamic_objects += 0LLU;
102973		- state.addr = 18446744073709545625LLU; // 99999998gY'''''''''''''''
	102751	+ state.addr = 18446744073709545633LLU; // 99999998gf'''''''''''''''
102974	102752	break;
102975	102753	}
102976		- case 18446744073709545626LLU: // 99999998gZ'''''''''''''''
	102754	+ case 18446744073709545634LLU: // 99999998gg'''''''''''''''
102977	102755	{
102978	102756	/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 5LLU)) = (uint64_t)getchar();
102979	102757	{

		@@ -102984,7 +102762,7 @@
102984	102762	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
102985	102763	}
102986	102764	// 1LLU
102987		- uint64_t return_to = 18446744073709545623LLU;
	102765	+ uint64_t return_to = 18446744073709545631LLU;
102988	102766	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
102989	102767	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
102990	102768	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -102993,12 +102771,12 @@
102993	102771	state.addr = 839519719621918720LLU; // skipws____
102994	102772	break;
102995	102773	}
102996		- case 18446744073709545623LLU: // 99999998gW'''''''''''''''
	102774	+ case 18446744073709545631LLU: // 99999998gd'''''''''''''''
102997	102775	{
102998		- state.addr = 18446744073709545624LLU; // 99999998gX'''''''''''''''
	102776	+ state.addr = 18446744073709545632LLU; // 99999998ge'''''''''''''''
102999	102777	break;
103000	102778	}
103001		- case 18446744073709545624LLU: // 99999998gX'''''''''''''''
	102779	+ case 18446744073709545632LLU: // 99999998ge'''''''''''''''
103002	102780	{
103003	102781	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 5LLU)), stdin);
103004	102782	if('\|' != (char)getchar())

		@@ -103006,32 +102784,32 @@
103006	102784	fprintf(stderr, "match failed at char %c\n", (char)124LLU);
103007	102785	exit(-1);
103008	102786	}
103009		- state.addr = 18446744073709545625LLU; // 99999998gY'''''''''''''''
	102787	+ state.addr = 18446744073709545633LLU; // 99999998gf'''''''''''''''
103010	102788	break;
103011	102789	}
103012		- case 18446744073709545625LLU: // 99999998gY'''''''''''''''
	102790	+ case 18446744073709545633LLU: // 99999998gf'''''''''''''''
103013	102791	{
103014	102792	// variable u64 simple____ goes out of scope
103015	102793	// emitted destructur for type u64
103016	102794	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference simple____ at 25
103017		- state.addr = 18446744073709545638LLU; // 99999998gk'''''''''''''''
	102795	+ state.addr = 18446744073709545646LLU; // 99999998gs'''''''''''''''
103018	102796	break;
103019	102797	}
103020		- case 18446744073709545637LLU: // 99999998gj'''''''''''''''
	102798	+ case 18446744073709545645LLU: // 99999998gr'''''''''''''''
103021	102799	{
103022	102800	/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 24LLU, 5LLU)) = (uint64_t)getchar();
103023	102801	// variable u64 caseaddr__ goes out of scope
103024	102802	// emitted destructur for type u64
103025	102803	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference caseaddr__ at 24
103026		- state.addr = 18446744073709545639LLU; // 99999998gl'''''''''''''''
	102804	+ state.addr = 18446744073709545647LLU; // 99999998gt'''''''''''''''
103027	102805	break;
103028	102806	}
103029		- case 18446744073709545639LLU: // 99999998gl'''''''''''''''
	102807	+ case 18446744073709545647LLU: // 99999998gt'''''''''''''''
103030	102808	{
103031		- state.addr = 18446744073709545641LLU; // 99999998gn'''''''''''''''
	102809	+ state.addr = 18446744073709545649LLU; // 99999998gv'''''''''''''''
103032	102810	break;
103033	102811	}
103034		- case 18446744073709545641LLU: // 99999998gn'''''''''''''''
	102812	+ case 18446744073709545649LLU: // 99999998gv'''''''''''''''
103035	102813	{
103036	102814	// variable u64 defined___ goes out of scope
103037	102815	// emitted destructur for type u64

		@@ -103043,14 +102821,14 @@
103043	102821	uint64_t arg = 0;
103044	102822	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
103045	102823	}
103046		- state.addr = 18446744073709545621LLU; // 99999998gU'''''''''''''''
	102824	+ state.addr = 18446744073709545629LLU; // 99999998gb'''''''''''''''
103047	102825	break;
103048	102826	}
103049		- case 18446744073709545621LLU: // 99999998gU'''''''''''''''
	102827	+ case 18446744073709545629LLU: // 99999998gb'''''''''''''''
103050	102828	{
103051	102829	if(!LOCAL_ACCESS(heap.data, 23LLU, 21LLU)/list*/)
103052	102830	{
103053		- state.addr = 18446744073709545622LLU; // 99999998gV'''''''''''''''
	102831	+ state.addr = 18446744073709545630LLU; // 99999998gc'''''''''''''''
103054	102832	break;
103055	102833	}
103056	102834	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 23LLU, 21LLU)/list/, 4);

		@@ -103062,7 +102840,7 @@
103062	102840	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103063	102841	}
103064	102842	// 1LLU
103065		- uint64_t return_to = 18446744073709545620LLU;
	102843	+ uint64_t return_to = 18446744073709545628LLU;
103066	102844	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103067	102845	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103068	102846	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103071,21 +102849,21 @@
103071	102849	state.addr = 838947815509198532LLU; // signdef_$D
103072	102850	break;
103073	102851	}
103074		- case 18446744073709545620LLU: // 99999998gT'''''''''''''''
	102852	+ case 18446744073709545628LLU: // 99999998ga'''''''''''''''
103075	102853	{
103076		- state.addr = 18446744073709545621LLU; // 99999998gU'''''''''''''''
	102854	+ state.addr = 18446744073709545629LLU; // 99999998gb'''''''''''''''
103077	102855	break;
103078	102856	}
103079		- case 18446744073709545622LLU: // 99999998gV'''''''''''''''
	102857	+ case 18446744073709545630LLU: // 99999998gc'''''''''''''''
103080	102858	{
103081	102859	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
103082	102860	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference signs_____ at 22
103083	102861	heap.availilable_size_for_dynamic_objects += 0LLU;
103084	102862	heap.availilable_size_for_dynamic_objects += 0LLU;
103085		- state.addr = 18446744073709545619LLU; // 99999998gS'''''''''''''''
	102863	+ state.addr = 18446744073709545627LLU; // 99999998g$'''''''''''''''
103086	102864	break;
103087	102865	}
103088		- case 18446744073709545715LLU: // 99999998hx'''''''''''''''
	102866	+ case 18446744073709545723LLU: // 99999998h5'''''''''''''''
103089	102867	{
103090	102868	{
103091	102869	uint64_t arg = 0LLU;

		@@ -103128,7 +102906,7 @@
103128	102906	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103129	102907	}
103130	102908	// 6LLU
103131		- uint64_t return_to = 18446744073709545616LLU;
	102909	+ uint64_t return_to = 18446744073709545624LLU;
103132	102910	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103133	102911	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103134	102912	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103137,12 +102915,12 @@
103137	102915	state.addr = 782701543533239168LLU; // parsepars_
103138	102916	break;
103139	102917	}
103140		- case 18446744073709545616LLU: // 99999998gP'''''''''''''''
	102918	+ case 18446744073709545624LLU: // 99999998gX'''''''''''''''
103141	102919	{
103142		- state.addr = 18446744073709545617LLU; // 99999998gQ'''''''''''''''
	102920	+ state.addr = 18446744073709545625LLU; // 99999998gY'''''''''''''''
103143	102921	break;
103144	102922	}
103145		- case 18446744073709545617LLU: // 99999998gQ'''''''''''''''
	102923	+ case 18446744073709545625LLU: // 99999998gY'''''''''''''''
103146	102924	{
103147	102925	{
103148	102926	uint64_t arg = 0LLU;

		@@ -103153,10 +102931,10 @@
103153	102931	// variable u64 argscount_ goes out of scope
103154	102932	// emitted destructur for type u64
103155	102933	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference argscount_ at 25
103156		- state.addr = 18446744073709545615LLU; // 99999998gO'''''''''''''''
	102934	+ state.addr = 18446744073709545623LLU; // 99999998gW'''''''''''''''
103157	102935	break;
103158	102936	}
103159		- case 18446744073709545615LLU: // 99999998gO'''''''''''''''
	102937	+ case 18446744073709545623LLU: // 99999998gW'''''''''''''''
103160	102938	{
103161	102939	{
103162	102940	uint64_t mainresult = heap.data[0].elem0;

		@@ -103166,7 +102944,7 @@
103166	102944	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103167	102945	}
103168	102946	// 1LLU
103169		- uint64_t return_to = 18446744073709545613LLU;
	102947	+ uint64_t return_to = 18446744073709545621LLU;
103170	102948	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103171	102949	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103172	102950	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103175,12 +102953,12 @@
103175	102953	state.addr = 839519719621918720LLU; // skipws____
103176	102954	break;
103177	102955	}
103178		- case 18446744073709545613LLU: // 99999998gM'''''''''''''''
	102956	+ case 18446744073709545621LLU: // 99999998gU'''''''''''''''
103179	102957	{
103180		- state.addr = 18446744073709545614LLU; // 99999998gN'''''''''''''''
	102958	+ state.addr = 18446744073709545622LLU; // 99999998gV'''''''''''''''
103181	102959	break;
103182	102960	}
103183		- case 18446744073709545614LLU: // 99999998gN'''''''''''''''
	102961	+ case 18446744073709545622LLU: // 99999998gV'''''''''''''''
103184	102962	{
103185	102963	/defbodysz_/LOCAL_ACCESS(heap.data, 24LLU, 14LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 24LLU, 5LLU)));
103186	102964	/remainsize/LOCAL_ACCESS(heap.data, 24LLU, 15LLU) = /defbodysz_/LOCAL_ACCESS(heap.data, 24LLU, 14LLU);

		@@ -103193,7 +102971,7 @@
103193	102971	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103194	102972	}
103195	102973	// 1LLU
103196		- uint64_t return_to = 18446744073709545611LLU;
	102974	+ uint64_t return_to = 18446744073709545619LLU;
103197	102975	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103198	102976	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103199	102977	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103202,12 +102980,12 @@
103202	102980	state.addr = 839519719621918720LLU; // skipws____
103203	102981	break;
103204	102982	}
103205		- case 18446744073709545611LLU: // 99999998gK'''''''''''''''
	102983	+ case 18446744073709545619LLU: // 99999998gS'''''''''''''''
103206	102984	{
103207		- state.addr = 18446744073709545612LLU; // 99999998gL'''''''''''''''
	102985	+ state.addr = 18446744073709545620LLU; // 99999998gT'''''''''''''''
103208	102986	break;
103209	102987	}
103210		- case 18446744073709545612LLU: // 99999998gL'''''''''''''''
	102988	+ case 18446744073709545620LLU: // 99999998gT'''''''''''''''
103211	102989	{
103212	102990	/remainheap/LOCAL_ACCESS(heap.data, 24LLU, 16LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 24LLU, 5LLU)));
103213	102991	list_reverse(heap.data, &/results___/*LOCAL_ACCESS(heap.data, 24LLU, 17LLU));

		@@ -103214,10 +102992,10 @@
103214	102992	// variable u64 returnbase goes out of scope
103215	102993	// emitted destructur for type u64
103216	102994	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference returnbase at 24
103217		- state.addr = 18446744073709545618LLU; // 99999998gR'''''''''''''''
	102995	+ state.addr = 18446744073709545626LLU; // 99999998gZ'''''''''''''''
103218	102996	break;
103219	102997	}
103220		- case 18446744073709545618LLU: // 99999998gR'''''''''''''''
	102998	+ case 18446744073709545626LLU: // 99999998gZ'''''''''''''''
103221	102999	{
103222	103000	/sym_______/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU) = 59LLU;
103223	103001

		@@ -103231,7 +103009,7 @@
103231	103009	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103232	103010	}
103233	103011	// 1LLU
103234		- uint64_t return_to = 18446744073709545608LLU;
	103012	+ uint64_t return_to = 18446744073709545616LLU;
103235	103013	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103236	103014	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103237	103015	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103240,12 +103018,12 @@
103240	103018	state.addr = 839519719621918720LLU; // skipws____
103241	103019	break;
103242	103020	}
103243		- case 18446744073709545608LLU: // 99999998gH'''''''''''''''
	103021	+ case 18446744073709545616LLU: // 99999998gP'''''''''''''''
103244	103022	{
103245		- state.addr = 18446744073709545609LLU; // 99999998gI'''''''''''''''
	103023	+ state.addr = 18446744073709545617LLU; // 99999998gQ'''''''''''''''
103246	103024	break;
103247	103025	}
103248		- case 18446744073709545609LLU: // 99999998gI'''''''''''''''
	103026	+ case 18446744073709545617LLU: // 99999998gQ'''''''''''''''
103249	103027	{
103250	103028	{
103251	103029	uint64_t mainresult = heap.data[0].elem0;

		@@ -103263,7 +103041,7 @@
103263	103041	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103264	103042	}
103265	103043	// 3LLU
103266		- uint64_t return_to = 18446744073709545606LLU;
	103044	+ uint64_t return_to = 18446744073709545614LLU;
103267	103045	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103268	103046	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103269	103047	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103272,38 +103050,38 @@
103272	103050	state.addr = 728666047794575267LLU; // matchoptch
103273	103051	break;
103274	103052	}
103275		- case 18446744073709545606LLU: // 99999998gF'''''''''''''''
	103053	+ case 18446744073709545614LLU: // 99999998gN'''''''''''''''
103276	103054	{
103277		- state.addr = 18446744073709545607LLU; // 99999998gG'''''''''''''''
	103055	+ state.addr = 18446744073709545615LLU; // 99999998gO'''''''''''''''
103278	103056	break;
103279	103057	}
103280		- case 18446744073709545607LLU: // 99999998gG'''''''''''''''
	103058	+ case 18446744073709545615LLU: // 99999998gO'''''''''''''''
103281	103059	{
103282		- state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545605LLU : 18446744073709545604LLU;
	103060	+ state.addr = /matchsym__/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) ? 18446744073709545613LLU : 18446744073709545612LLU;
103283	103061	break;
103284	103062	}
103285		- case 18446744073709545605LLU: // 99999998gE'''''''''''''''
	103063	+ case 18446744073709545613LLU: // 99999998gM'''''''''''''''
103286	103064	{
103287	103065	/defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0LLU;
103288	103066
103289	103067	heap.availilable_size_for_dynamic_objects += 0LLU;
103290	103068	heap.availilable_size_for_dynamic_objects += 0LLU;
103291		- state.addr = 18446744073709545603LLU; // 99999998gC'''''''''''''''
	103069	+ state.addr = 18446744073709545611LLU; // 99999998gK'''''''''''''''
103292	103070	break;
103293	103071	}
103294		- case 18446744073709545604LLU: // 99999998gD'''''''''''''''
	103072	+ case 18446744073709545612LLU: // 99999998gL'''''''''''''''
103295	103073	{
103296	103074	/defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 1LLU;
103297	103075
103298		- state.addr = 18446744073709545603LLU; // 99999998gC'''''''''''''''
	103076	+ state.addr = 18446744073709545611LLU; // 99999998gK'''''''''''''''
103299	103077	break;
103300	103078	}
103301		- case 18446744073709545603LLU: // 99999998gC'''''''''''''''
	103079	+ case 18446744073709545611LLU: // 99999998gK'''''''''''''''
103302	103080	{
103303		- state.addr = 18446744073709545610LLU; // 99999998gJ'''''''''''''''
	103081	+ state.addr = 18446744073709545618LLU; // 99999998gR'''''''''''''''
103304	103082	break;
103305	103083	}
103306		- case 18446744073709545610LLU: // 99999998gJ'''''''''''''''
	103084	+ case 18446744073709545618LLU: // 99999998gR'''''''''''''''
103307	103085	{
103308	103086	{
103309	103087	uint64_t arg = 0LLU;

		@@ -103353,7 +103131,7 @@
103353	103131	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103354	103132	}
103355	103133	// 10LLU
103356		- uint64_t return_to = 18446744073709545600LLU;
	103134	+ uint64_t return_to = 18446744073709545608LLU;
103357	103135	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103358	103136	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103359	103137	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103362,12 +103140,12 @@
103362	103140	state.addr = 728626598349373440LLU; // makedef___
103363	103141	break;
103364	103142	}
103365		- case 18446744073709545600LLU: // 99999998g_'''''''''''''''
	103143	+ case 18446744073709545608LLU: // 99999998gH'''''''''''''''
103366	103144	{
103367		- state.addr = 18446744073709545601LLU; // 99999998gA'''''''''''''''
	103145	+ state.addr = 18446744073709545609LLU; // 99999998gI'''''''''''''''
103368	103146	break;
103369	103147	}
103370		- case 18446744073709545601LLU: // 99999998gA'''''''''''''''
	103148	+ case 18446744073709545609LLU: // 99999998gI'''''''''''''''
103371	103149	{
103372	103150	{
103373	103151	uint64_t arg = 1LLU;

		@@ -103381,10 +103159,10 @@
103381	103159	uint64_t arg = 0;
103382	103160	LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
103383	103161	}
103384		- state.addr = 18446744073709545599LLU; // 99999998f9'''''''''''''''
	103162	+ state.addr = 18446744073709545607LLU; // 99999998gG'''''''''''''''
103385	103163	break;
103386	103164	}
103387		- case 18446744073709545599LLU: // 99999998f9'''''''''''''''
	103165	+ case 18446744073709545607LLU: // 99999998gG'''''''''''''''
103388	103166	{
103389	103167	if(!*LOCAL_ACCESS(heap.data, 27LLU, 25LLU))
103390	103168	{

		@@ -103391,16 +103169,16 @@
103391	103169	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
103392	103170	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 26
103393	103171	{
103394		- state.addr = 18446744073709545598LLU; // 99999998f8'''''''''''''''
	103172	+ state.addr = 18446744073709545606LLU; // 99999998gF'''''''''''''''
103395	103173	break;
103396	103174	}
103397	103175	}
103398	103176	/direct/LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = (LOCAL_ACCESS(heap.data, 27LLU, 25LLU) << 1) + 1LLU;
103399	103177	LOCAL_ACCESS(heap.data, 27LLU, 25LLU) = heap.data[LOCAL_ACCESS(heap.data, 27LLU, 25LLU)].elem0;
103400		- state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545597LLU : 18446744073709545596LLU;
	103178	+ state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 27LLU, 24LLU) ? 18446744073709545605LLU : 18446744073709545604LLU;
103401	103179	break;
103402	103180	}
103403		- case 18446744073709545597LLU: // 99999998f7'''''''''''''''
	103181	+ case 18446744073709545605LLU: // 99999998gE'''''''''''''''
103404	103182	{
103405	103183	{
103406	103184	uint64_t arg = 0LLU;

		@@ -103407,10 +103185,10 @@
103407	103185	LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/address of current closure/, &arg);
103408	103186	}
103409	103187	/match_____/LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = /id________/LOCAL_ACCESS(heap.data, 28LLU, 7LLU) == /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 0LLU));
103410		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545595LLU : 18446744073709545594LLU;
	103188	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545603LLU : 18446744073709545602LLU;
103411	103189	break;
103412	103190	}
103413		- case 18446744073709545595LLU: // 99999998f5'''''''''''''''
	103191	+ case 18446744073709545603LLU: // 99999998gC'''''''''''''''
103414	103192	{
103415	103193	/fresh_____/*LOCAL_ACCESS(heap.data, 28LLU, 24LLU) = 0LLU;
103416	103194

		@@ -103430,7 +103208,7 @@
103430	103208	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103431	103209	}
103432	103210	// 3LLU
103433		- uint64_t return_to = 18446744073709545592LLU;
	103211	+ uint64_t return_to = 18446744073709545600LLU;
103434	103212	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103435	103213	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103436	103214	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103439,22 +103217,22 @@
103439	103217	state.addr = 589059069805989888LLU; // equfndef__
103440	103218	break;
103441	103219	}
103442		- case 18446744073709545592LLU: // 99999998f2'''''''''''''''
	103220	+ case 18446744073709545600LLU: // 99999998g_'''''''''''''''
103443	103221	{
103444		- state.addr = 18446744073709545593LLU; // 99999998f3'''''''''''''''
	103222	+ state.addr = 18446744073709545601LLU; // 99999998gA'''''''''''''''
103445	103223	break;
103446	103224	}
103447		- case 18446744073709545593LLU: // 99999998f3'''''''''''''''
	103225	+ case 18446744073709545601LLU: // 99999998gA'''''''''''''''
103448	103226	{
103449		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545591LLU : 18446744073709545590LLU;
	103227	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 28LLU, 27LLU) ? 18446744073709545599LLU : 18446744073709545598LLU;
103450	103228	break;
103451	103229	}
103452		- case 18446744073709545591LLU: // 99999998f1'''''''''''''''
	103230	+ case 18446744073709545599LLU: // 99999998f9'''''''''''''''
103453	103231	{
103454		- state.addr = /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545589LLU : 18446744073709545588LLU;
	103232	+ state.addr = /previous__/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 28LLU, 26LLU), 2LLU)) ? 18446744073709545597LLU : 18446744073709545596LLU;
103455	103233	break;
103456	103234	}
103457		- case 18446744073709545589LLU: // 99999998fz'''''''''''''''
	103235	+ case 18446744073709545597LLU: // 99999998f7'''''''''''''''
103458	103236	{
103459	103237	fprintf(stderr, "%s", "re-definition of ");
103460	103238	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));

		@@ -103464,42 +103242,42 @@
103464	103242	}
103465	103243	heap.availilable_size_for_dynamic_objects += 0LLU;
103466	103244	heap.availilable_size_for_dynamic_objects += 0LLU;
103467		- state.addr = 18446744073709545587LLU; // 99999998fx'''''''''''''''
	103245	+ state.addr = 18446744073709545595LLU; // 99999998f5'''''''''''''''
103468	103246	break;
103469	103247	}
103470		- case 18446744073709545588LLU: // 99999998fy'''''''''''''''
	103248	+ case 18446744073709545596LLU: // 99999998f6'''''''''''''''
103471	103249	{
103472		- state.addr = /current___/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545586LLU : 18446744073709545585LLU;
	103250	+ state.addr = /current___/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 23LLU), 2LLU)) ? 18446744073709545594LLU : 18446744073709545593LLU;
103473	103251	break;
103474	103252	}
103475		- case 18446744073709545586LLU: // 99999998fw'''''''''''''''
	103253	+ case 18446744073709545594LLU: // 99999998f4'''''''''''''''
103476	103254	{
103477	103255	swap(&/current___/LOCAL_ACCESS(heap.data, 28LLU, 23LLU), &/previous__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 28LLU, 26LLU)));
103478	103256	heap.availilable_size_for_dynamic_objects += 0LLU;
103479	103257	heap.availilable_size_for_dynamic_objects += 0LLU;
103480		- state.addr = 18446744073709545584LLU; // 99999998fu'''''''''''''''
	103258	+ state.addr = 18446744073709545592LLU; // 99999998f2'''''''''''''''
103481	103259	break;
103482	103260	}
103483		- case 18446744073709545585LLU: // 99999998fv'''''''''''''''
	103261	+ case 18446744073709545593LLU: // 99999998f3'''''''''''''''
103484	103262	{
103485	103263	fprintf(stderr, "%s", "WARNING: superfluous re-declaration of ");
103486	103264	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));
103487		- state.addr = 18446744073709545584LLU; // 99999998fu'''''''''''''''
	103265	+ state.addr = 18446744073709545592LLU; // 99999998f2'''''''''''''''
103488	103266	break;
103489	103267	}
103490		- case 18446744073709545584LLU: // 99999998fu'''''''''''''''
	103268	+ case 18446744073709545592LLU: // 99999998f2'''''''''''''''
103491	103269	{
103492		- state.addr = 18446744073709545587LLU; // 99999998fx'''''''''''''''
	103270	+ state.addr = 18446744073709545595LLU; // 99999998f5'''''''''''''''
103493	103271	break;
103494	103272	}
103495		- case 18446744073709545587LLU: // 99999998fx'''''''''''''''
	103273	+ case 18446744073709545595LLU: // 99999998f5'''''''''''''''
103496	103274	{
103497	103275	heap.availilable_size_for_dynamic_objects += 0LLU;
103498	103276	heap.availilable_size_for_dynamic_objects += 0LLU;
103499		- state.addr = 18446744073709545583LLU; // 99999998ft'''''''''''''''
	103277	+ state.addr = 18446744073709545591LLU; // 99999998f1'''''''''''''''
103500	103278	break;
103501	103279	}
103502		- case 18446744073709545590LLU: // 99999998f0'''''''''''''''
	103280	+ case 18446744073709545598LLU: // 99999998f8'''''''''''''''
103503	103281	{
103504	103282	fprintf(stderr, "%s", "re-definition of ");
103505	103283	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 28LLU, 7LLU));

		@@ -103508,35 +103286,35 @@
103508	103286	fprintf(stderr, "%s\n", "");
103509	103287	exit(-1);
103510	103288	}
103511		- state.addr = 18446744073709545583LLU; // 99999998ft'''''''''''''''
	103289	+ state.addr = 18446744073709545591LLU; // 99999998f1'''''''''''''''
103512	103290	break;
103513	103291	}
103514		- case 18446744073709545583LLU: // 99999998ft'''''''''''''''
	103292	+ case 18446744073709545591LLU: // 99999998f1'''''''''''''''
103515	103293	{
103516		- state.addr = 18446744073709545594LLU; // 99999998f4'''''''''''''''
	103294	+ state.addr = 18446744073709545602LLU; // 99999998gB'''''''''''''''
103517	103295	break;
103518	103296	}
103519		- case 18446744073709545594LLU: // 99999998f4'''''''''''''''
	103297	+ case 18446744073709545602LLU: // 99999998gB'''''''''''''''
103520	103298	{
103521	103299	// variable u64 match_____ goes out of scope
103522	103300	// emitted destructur for type u64
103523	103301	(void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 28
103524		- state.addr = 18446744073709545596LLU; // 99999998f6'''''''''''''''
	103302	+ state.addr = 18446744073709545604LLU; // 99999998gD'''''''''''''''
103525	103303	break;
103526	103304	}
103527		- case 18446744073709545596LLU: // 99999998f6'''''''''''''''
	103305	+ case 18446744073709545604LLU: // 99999998gD'''''''''''''''
103528	103306	{
103529	103307	// parameter-reference defidfn___ previous__ goes out of scope
103530	103308	// parameter-reference list<defidfn___> fndefs____ goes out of scope
103531		- state.addr = 18446744073709545599LLU; // 99999998f9'''''''''''''''
	103309	+ state.addr = 18446744073709545607LLU; // 99999998gG'''''''''''''''
103532	103310	break;
103533	103311	}
103534		- case 18446744073709545598LLU: // 99999998f8'''''''''''''''
	103312	+ case 18446744073709545606LLU: // 99999998gF'''''''''''''''
103535	103313	{
103536		- state.addr = !list_push_move(&heap, &/current___/LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/fndefs____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 9) ? 18446744073709545581LLU : 18446744073709545580LLU;
	103314	+ state.addr = !list_push_move(&heap, &/current___/LOCAL_ACCESS(heap.data, 25LLU, 23LLU), &/fndefs____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 2LLU)), 9) ? 18446744073709545589LLU : 18446744073709545588LLU;
103537	103315	break;
103538	103316	}
103539		- case 18446744073709545581LLU: // 99999998fr'''''''''''''''
	103317	+ case 18446744073709545589LLU: // 99999998fz'''''''''''''''
103540	103318	{
103541	103319	{
103542	103320	uint64_t arg = *LOCAL_ACCESS(heap.data, 25LLU, 23LLU);

		@@ -103559,7 +103337,7 @@
103559	103337	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103560	103338	}
103561	103339	// 1LLU
103562		- uint64_t return_to = 18446744073709545579LLU;
	103340	+ uint64_t return_to = 18446744073709545587LLU;
103563	103341	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103564	103342	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103565	103343	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103568,32 +103346,32 @@
103568	103346	state.addr = 567601196335105732LLU; // defidfn_$D
103569	103347	break;
103570	103348	}
103571		- case 18446744073709545579LLU: // 99999998fp'''''''''''''''
	103349	+ case 18446744073709545587LLU: // 99999998fx'''''''''''''''
103572	103350	{
103573	103351	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference current___ at 26
103574	103352	heap.availilable_size_for_dynamic_objects += 0LLU;
103575	103353	heap.availilable_size_for_dynamic_objects += 0LLU;
103576		- state.addr = 18446744073709545578LLU; // 99999998fo'''''''''''''''
	103354	+ state.addr = 18446744073709545586LLU; // 99999998fw'''''''''''''''
103577	103355	break;
103578	103356	}
103579		- case 18446744073709545580LLU: // 99999998fq'''''''''''''''
	103357	+ case 18446744073709545588LLU: // 99999998fy'''''''''''''''
103580	103358	{
103581		- state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545577LLU : 18446744073709545576LLU;
	103359	+ state.addr = /fresh_____/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU) ? 18446744073709545585LLU : 18446744073709545584LLU;
103582	103360	break;
103583	103361	}
103584		- case 18446744073709545577LLU: // 99999998fn'''''''''''''''
	103362	+ case 18446744073709545585LLU: // 99999998fv'''''''''''''''
103585	103363	{
103586	103364	heap.availilable_size_for_dynamic_objects += 0LLU;
103587	103365	heap.availilable_size_for_dynamic_objects += 0LLU;
103588		- state.addr = 18446744073709545575LLU; // 99999998fl'''''''''''''''
	103366	+ state.addr = 18446744073709545583LLU; // 99999998ft'''''''''''''''
103589	103367	break;
103590	103368	}
103591		- case 18446744073709545576LLU: // 99999998fm'''''''''''''''
	103369	+ case 18446744073709545584LLU: // 99999998fu'''''''''''''''
103592	103370	{
103593		- state.addr = /fndefs____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545574LLU : 18446744073709545573LLU;
	103371	+ state.addr = /fndefs____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU)) ? 18446744073709545582LLU : 18446744073709545581LLU;
103594	103372	break;
103595	103373	}
103596		- case 18446744073709545574LLU: // 99999998fk'''''''''''''''
	103374	+ case 18446744073709545582LLU: // 99999998fs'''''''''''''''
103597	103375	{
103598	103376	{
103599	103377	uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 25LLU, 2LLU))/list/, 9);

		@@ -103609,7 +103387,7 @@
103609	103387	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103610	103388	}
103611	103389	// 1LLU
103612		- uint64_t return_to = 18446744073709545572LLU;
	103390	+ uint64_t return_to = 18446744073709545580LLU;
103613	103391	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103614	103392	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103615	103393	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103618,39 +103396,39 @@
103618	103396	state.addr = 567601196335105732LLU; // defidfn_$D
103619	103397	break;
103620	103398	}
103621		- case 18446744073709545572LLU: // 99999998fi'''''''''''''''
	103399	+ case 18446744073709545580LLU: // 99999998fq'''''''''''''''
103622	103400	{
103623	103401	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dummy_____ at 26
103624	103402	heap.availilable_size_for_dynamic_objects += 0LLU;
103625	103403	heap.availilable_size_for_dynamic_objects += 0LLU;
103626		- state.addr = 18446744073709545571LLU; // 99999998fh'''''''''''''''
	103404	+ state.addr = 18446744073709545579LLU; // 99999998fp'''''''''''''''
103627	103405	break;
103628	103406	}
103629		- case 18446744073709545573LLU: // 99999998fj'''''''''''''''
	103407	+ case 18446744073709545581LLU: // 99999998fr'''''''''''''''
103630	103408	{
103631	103409	{
103632	103410	fprintf(stderr, "%s\n", "INTERNAL COMPILER ERROR in clumsy decl-replace-code: this should never happen!");
103633	103411	exit(-1);
103634	103412	}
103635		- state.addr = 18446744073709545571LLU; // 99999998fh'''''''''''''''
	103413	+ state.addr = 18446744073709545579LLU; // 99999998fp'''''''''''''''
103636	103414	break;
103637	103415	}
103638		- case 18446744073709545571LLU: // 99999998fh'''''''''''''''
	103416	+ case 18446744073709545579LLU: // 99999998fp'''''''''''''''
103639	103417	{
103640		- state.addr = 18446744073709545575LLU; // 99999998fl'''''''''''''''
	103418	+ state.addr = 18446744073709545583LLU; // 99999998ft'''''''''''''''
103641	103419	break;
103642	103420	}
103643		- case 18446744073709545575LLU: // 99999998fl'''''''''''''''
	103421	+ case 18446744073709545583LLU: // 99999998ft'''''''''''''''
103644	103422	{
103645		- state.addr = 18446744073709545578LLU; // 99999998fo'''''''''''''''
	103423	+ state.addr = 18446744073709545586LLU; // 99999998fw'''''''''''''''
103646	103424	break;
103647	103425	}
103648		- case 18446744073709545578LLU: // 99999998fo'''''''''''''''
	103426	+ case 18446744073709545586LLU: // 99999998fw'''''''''''''''
103649	103427	{
103650		- state.addr = 18446744073709545582LLU; // 99999998fs'''''''''''''''
	103428	+ state.addr = 18446744073709545590LLU; // 99999998f0'''''''''''''''
103651	103429	break;
103652	103430	}
103653		- case 18446744073709545582LLU: // 99999998fs'''''''''''''''
	103431	+ case 18446744073709545590LLU: // 99999998f0'''''''''''''''
103654	103432	{
103655	103433	// variable u64 fresh_____ goes out of scope
103656	103434	// emitted destructur for type u64

		@@ -103658,15 +103436,15 @@
103658	103436	// variable defidfn___ current___ goes out of scope
103659	103437	// (uninitialized -> no destructor-call)
103660	103438	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference current___ at 24
103661		- state.addr = 18446744073709545602LLU; // 99999998gB'''''''''''''''
	103439	+ state.addr = 18446744073709545610LLU; // 99999998gJ'''''''''''''''
103662	103440	break;
103663	103441	}
103664		- case 18446744073709545602LLU: // 99999998gB'''''''''''''''
	103442	+ case 18446744073709545610LLU: // 99999998gJ'''''''''''''''
103665	103443	{
103666		- state.addr = /defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545570LLU : 18446744073709545569LLU;
	103444	+ state.addr = /defined___/*LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709545578LLU : 18446744073709545577LLU;
103667	103445	break;
103668	103446	}
103669		- case 18446744073709545570LLU: // 99999998fg'''''''''''''''
	103447	+ case 18446744073709545578LLU: // 99999998fo'''''''''''''''
103670	103448	{
103671	103449	{
103672	103450	uint64_t mainresult = heap.data[0].elem0;

		@@ -103676,7 +103454,7 @@
103676	103454	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103677	103455	}
103678	103456	// 1LLU
103679		- uint64_t return_to = 18446744073709545567LLU;
	103457	+ uint64_t return_to = 18446744073709545575LLU;
103680	103458	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103681	103459	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103682	103460	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103685,12 +103463,12 @@
103685	103463	state.addr = 587881345921715008LLU; // emitenter_
103686	103464	break;
103687	103465	}
103688		- case 18446744073709545567LLU: // 99999998fd'''''''''''''''
	103466	+ case 18446744073709545575LLU: // 99999998fl'''''''''''''''
103689	103467	{
103690		- state.addr = 18446744073709545568LLU; // 99999998fe'''''''''''''''
	103468	+ state.addr = 18446744073709545576LLU; // 99999998fm'''''''''''''''
103691	103469	break;
103692	103470	}
103693		- case 18446744073709545568LLU: // 99999998fe'''''''''''''''
	103471	+ case 18446744073709545576LLU: // 99999998fm'''''''''''''''
103694	103472	{
103695	103473	{
103696	103474	uint64_t mainresult = heap.data[0].elem0;

		@@ -103700,7 +103478,7 @@
103700	103478	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103701	103479	}
103702	103480	// 1LLU
103703		- uint64_t return_to = 18446744073709545565LLU;
	103481	+ uint64_t return_to = 18446744073709545573LLU;
103704	103482	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103705	103483	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103706	103484	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103709,12 +103487,12 @@
103709	103487	state.addr = 839519719621918720LLU; // skipws____
103710	103488	break;
103711	103489	}
103712		- case 18446744073709545565LLU: // 99999998fb'''''''''''''''
	103490	+ case 18446744073709545573LLU: // 99999998fj'''''''''''''''
103713	103491	{
103714		- state.addr = 18446744073709545566LLU; // 99999998fc'''''''''''''''
	103492	+ state.addr = 18446744073709545574LLU; // 99999998fk'''''''''''''''
103715	103493	break;
103716	103494	}
103717		- case 18446744073709545566LLU: // 99999998fc'''''''''''''''
	103495	+ case 18446744073709545574LLU: // 99999998fk'''''''''''''''
103718	103496	{
103719	103497	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 5LLU)), stdin);
103720	103498	if('{' != (char)getchar())

		@@ -103722,15 +103500,15 @@
103722	103500	fprintf(stderr, "match failed at char %c\n", (char)123LLU);
103723	103501	exit(-1);
103724	103502	}
103725		- state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
	103503	+ state.addr = 18446744073709545572LLU; // 99999998fi'''''''''''''''
103726	103504	break;
103727	103505	}
103728		- case 18446744073709545564LLU: // 99999998fa'''''''''''''''
	103506	+ case 18446744073709545572LLU: // 99999998fi'''''''''''''''
103729	103507	{
103730	103508	access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) = (uint64_t)getchar();
103731	103509	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 23LLU, 5LLU)) > 255)
103732	103510	{
103733		- state.addr = 18446744073709545563LLU; // 99999998f$'''''''''''''''
	103511	+ state.addr = 18446744073709545571LLU; // 99999998fh'''''''''''''''
103734	103512	break;
103735	103513	}
103736	103514	{

		@@ -103801,7 +103579,7 @@
103801	103579	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103802	103580	}
103803	103581	// 16LLU
103804		- uint64_t return_to = 18446744073709545561LLU;
	103582	+ uint64_t return_to = 18446744073709545569LLU;
103805	103583	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103806	103584	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103807	103585	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103810,40 +103588,40 @@
103810	103588	state.addr = 782701543301228454LLU; // parseblock
103811	103589	break;
103812	103590	}
103813		- case 18446744073709545561LLU: // 99999998fY'''''''''''''''
	103591	+ case 18446744073709545569LLU: // 99999998ff'''''''''''''''
103814	103592	{
103815		- state.addr = 18446744073709545562LLU; // 99999998fZ'''''''''''''''
	103593	+ state.addr = 18446744073709545570LLU; // 99999998fg'''''''''''''''
103816	103594	break;
103817	103595	}
103818		- case 18446744073709545562LLU: // 99999998fZ'''''''''''''''
	103596	+ case 18446744073709545570LLU: // 99999998fg'''''''''''''''
103819	103597	{
103820		- state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
	103598	+ state.addr = 18446744073709545572LLU; // 99999998fi'''''''''''''''
103821	103599	break;
103822	103600	}
103823		- case 18446744073709545563LLU: // 99999998f$'''''''''''''''
	103601	+ case 18446744073709545571LLU: // 99999998fh'''''''''''''''
103824	103602	{
103825		- state.addr = /varlist___/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545560LLU : 18446744073709545559LLU;
	103603	+ state.addr = /varlist___/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU) ? 18446744073709545568LLU : 18446744073709545567LLU;
103826	103604	break;
103827	103605	}
103828		- case 18446744073709545560LLU: // 99999998fX'''''''''''''''
	103606	+ case 18446744073709545568LLU: // 99999998fe'''''''''''''''
103829	103607	{
103830	103608	{
103831	103609	fprintf(stderr, "%s\n", "INTERNAL ERROR: varlist not empty at end of definition\n");
103832	103610	exit(-1);
103833	103611	}
103834		- state.addr = 18446744073709545559LLU; // 99999998fW'''''''''''''''
	103612	+ state.addr = 18446744073709545567LLU; // 99999998fd'''''''''''''''
103835	103613	break;
103836	103614	}
103837		- case 18446744073709545559LLU: // 99999998fW'''''''''''''''
	103615	+ case 18446744073709545567LLU: // 99999998fd'''''''''''''''
103838	103616	{
103839		- state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
	103617	+ state.addr = 18446744073709545566LLU; // 99999998fc'''''''''''''''
103840	103618	break;
103841	103619	}
103842		- case 18446744073709545558LLU: // 99999998fV'''''''''''''''
	103620	+ case 18446744073709545566LLU: // 99999998fc'''''''''''''''
103843	103621	{
103844	103622	if(!/results___/*LOCAL_ACCESS(heap.data, 23LLU, 17LLU))
103845	103623	{
103846		- state.addr = 18446744073709545557LLU; // 99999998fU'''''''''''''''
	103624	+ state.addr = 18446744073709545565LLU; // 99999998fb'''''''''''''''
103847	103625	break;
103848	103626	}
103849	103627	{

		@@ -103874,7 +103652,7 @@
103874	103652	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103875	103653	}
103876	103654	// 4LLU
103877		- uint64_t return_to = 18446744073709545555LLU;
	103655	+ uint64_t return_to = 18446744073709545563LLU;
103878	103656	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103879	103657	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103880	103658	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103883,12 +103661,12 @@
103883	103661	state.addr = 587881357748656161LLU; // emitpopref
103884	103662	break;
103885	103663	}
103886		- case 18446744073709545555LLU: // 99999998fS'''''''''''''''
	103664	+ case 18446744073709545563LLU: // 99999998f$'''''''''''''''
103887	103665	{
103888		- state.addr = 18446744073709545556LLU; // 99999998fT'''''''''''''''
	103666	+ state.addr = 18446744073709545564LLU; // 99999998fa'''''''''''''''
103889	103667	break;
103890	103668	}
103891		- case 18446744073709545556LLU: // 99999998fT'''''''''''''''
	103669	+ case 18446744073709545564LLU: // 99999998fa'''''''''''''''
103892	103670	{
103893	103671	// variable u64 resultid__ goes out of scope
103894	103672	// emitted destructur for type u64

		@@ -103904,7 +103682,7 @@
103904	103682	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103905	103683	}
103906	103684	// 1LLU
103907		- uint64_t return_to = 18446744073709545554LLU;
	103685	+ uint64_t return_to = 18446744073709545562LLU;
103908	103686	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103909	103687	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103910	103688	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103913,13 +103691,13 @@
103913	103691	state.addr = 819859607768532676LLU; // resdest_$D
103914	103692	break;
103915	103693	}
103916		- case 18446744073709545554LLU: // 99999998fR'''''''''''''''
	103694	+ case 18446744073709545562LLU: // 99999998fZ'''''''''''''''
103917	103695	{
103918	103696	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference respar____ at 24
103919		- state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
	103697	+ state.addr = 18446744073709545566LLU; // 99999998fc'''''''''''''''
103920	103698	break;
103921	103699	}
103922		- case 18446744073709545557LLU: // 99999998fU'''''''''''''''
	103700	+ case 18446744073709545565LLU: // 99999998fb'''''''''''''''
103923	103701	{
103924	103702	{
103925	103703	uint64_t mainresult = heap.data[0].elem0;

		@@ -103937,7 +103715,7 @@
103937	103715	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103938	103716	}
103939	103717	// 3LLU
103940		- uint64_t return_to = 18446744073709545552LLU;
	103718	+ uint64_t return_to = 18446744073709545560LLU;
103941	103719	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103942	103720	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
103943	103721	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -103946,24 +103724,24 @@
103946	103724	state.addr = 587881353282000896LLU; // emitleave_
103947	103725	break;
103948	103726	}
103949		- case 18446744073709545552LLU: // 99999998fP'''''''''''''''
	103727	+ case 18446744073709545560LLU: // 99999998fX'''''''''''''''
103950	103728	{
103951		- state.addr = 18446744073709545553LLU; // 99999998fQ'''''''''''''''
	103729	+ state.addr = 18446744073709545561LLU; // 99999998fY'''''''''''''''
103952	103730	break;
103953	103731	}
103954		- case 18446744073709545553LLU: // 99999998fQ'''''''''''''''
	103732	+ case 18446744073709545561LLU: // 99999998fY'''''''''''''''
103955	103733	{
103956	103734	heap.availilable_size_for_dynamic_objects += 0LLU;
103957	103735	heap.availilable_size_for_dynamic_objects += 0LLU;
103958		- state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
	103736	+ state.addr = 18446744073709545559LLU; // 99999998fW'''''''''''''''
103959	103737	break;
103960	103738	}
103961		- case 18446744073709545569LLU: // 99999998ff'''''''''''''''
	103739	+ case 18446744073709545577LLU: // 99999998fn'''''''''''''''
103962	103740	{
103963		- state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
	103741	+ state.addr = 18446744073709545559LLU; // 99999998fW'''''''''''''''
103964	103742	break;
103965	103743	}
103966		- case 18446744073709545551LLU: // 99999998fO'''''''''''''''
	103744	+ case 18446744073709545559LLU: // 99999998fW'''''''''''''''
103967	103745	{
103968	103746	// variable u64 defined___ goes out of scope
103969	103747	// emitted destructur for type u64

		@@ -103975,14 +103753,14 @@
103975	103753	uint64_t arg = 0;
103976	103754	LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
103977	103755	}
103978		- state.addr = 18446744073709545549LLU; // 99999998fM'''''''''''''''
	103756	+ state.addr = 18446744073709545557LLU; // 99999998fU'''''''''''''''
103979	103757	break;
103980	103758	}
103981		- case 18446744073709545549LLU: // 99999998fM'''''''''''''''
	103759	+ case 18446744073709545557LLU: // 99999998fU'''''''''''''''
103982	103760	{
103983	103761	if(!LOCAL_ACCESS(heap.data, 23LLU, 21LLU)/list*/)
103984	103762	{
103985		- state.addr = 18446744073709545550LLU; // 99999998fN'''''''''''''''
	103763	+ state.addr = 18446744073709545558LLU; // 99999998fV'''''''''''''''
103986	103764	break;
103987	103765	}
103988	103766	LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 23LLU, 21LLU)/list/, 9);

		@@ -103994,7 +103772,7 @@
103994	103772	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
103995	103773	}
103996	103774	// 1LLU
103997		- uint64_t return_to = 18446744073709545548LLU;
	103775	+ uint64_t return_to = 18446744073709545556LLU;
103998	103776	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
103999	103777	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104000	103778	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104003,19 +103781,19 @@
104003	103781	state.addr = 890786982252725956LLU; // varentry$D
104004	103782	break;
104005	103783	}
104006		- case 18446744073709545548LLU: // 99999998fL'''''''''''''''
	103784	+ case 18446744073709545556LLU: // 99999998fT'''''''''''''''
104007	103785	{
104008		- state.addr = 18446744073709545549LLU; // 99999998fM'''''''''''''''
	103786	+ state.addr = 18446744073709545557LLU; // 99999998fU'''''''''''''''
104009	103787	break;
104010	103788	}
104011		- case 18446744073709545550LLU: // 99999998fN'''''''''''''''
	103789	+ case 18446744073709545558LLU: // 99999998fV'''''''''''''''
104012	103790	{
104013	103791	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 23
104014	103792	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varlist___ at 22
104015		- state.addr = 18446744073709545619LLU; // 99999998gS'''''''''''''''
	103793	+ state.addr = 18446744073709545627LLU; // 99999998g$'''''''''''''''
104016	103794	break;
104017	103795	}
104018		- case 18446744073709545619LLU: // 99999998gS'''''''''''''''
	103796	+ case 18446744073709545627LLU: // 99999998g$'''''''''''''''
104019	103797	{
104020	103798	// variable u64 matchsym__ goes out of scope
104021	103799	// emitted destructur for type u64

		@@ -104030,14 +103808,14 @@
104030	103808	uint64_t arg = 0;
104031	103809	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
104032	103810	}
104033		- state.addr = 18446744073709545546LLU; // 99999998fJ'''''''''''''''
	103811	+ state.addr = 18446744073709545554LLU; // 99999998fR'''''''''''''''
104034	103812	break;
104035	103813	}
104036		- case 18446744073709545546LLU: // 99999998fJ'''''''''''''''
	103814	+ case 18446744073709545554LLU: // 99999998fR'''''''''''''''
104037	103815	{
104038	103816	if(!LOCAL_ACCESS(heap.data, 20LLU, 18LLU)/list*/)
104039	103817	{
104040		- state.addr = 18446744073709545547LLU; // 99999998fK'''''''''''''''
	103818	+ state.addr = 18446744073709545555LLU; // 99999998fS'''''''''''''''
104041	103819	break;
104042	103820	}
104043	103821	LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 20LLU, 18LLU)/list/, 6);

		@@ -104049,7 +103827,7 @@
104049	103827	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104050	103828	}
104051	103829	// 1LLU
104052		- uint64_t return_to = 18446744073709545545LLU;
	103830	+ uint64_t return_to = 18446744073709545553LLU;
104053	103831	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104054	103832	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104055	103833	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104058,12 +103836,12 @@
104058	103836	state.addr = 782700512565790404LLU; // pardef__$D
104059	103837	break;
104060	103838	}
104061		- case 18446744073709545545LLU: // 99999998fI'''''''''''''''
	103839	+ case 18446744073709545553LLU: // 99999998fQ'''''''''''''''
104062	103840	{
104063		- state.addr = 18446744073709545546LLU; // 99999998fJ'''''''''''''''
	103841	+ state.addr = 18446744073709545554LLU; // 99999998fR'''''''''''''''
104064	103842	break;
104065	103843	}
104066		- case 18446744073709545547LLU: // 99999998fK'''''''''''''''
	103844	+ case 18446744073709545555LLU: // 99999998fS'''''''''''''''
104067	103845	{
104068	103846	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
104069	103847	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defpars___ at 19

		@@ -104074,14 +103852,14 @@
104074	103852	uint64_t arg = 0;
104075	103853	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
104076	103854	}
104077		- state.addr = 18446744073709545543LLU; // 99999998fG'''''''''''''''
	103855	+ state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
104078	103856	break;
104079	103857	}
104080		- case 18446744073709545543LLU: // 99999998fG'''''''''''''''
	103858	+ case 18446744073709545551LLU: // 99999998fO'''''''''''''''
104081	103859	{
104082	103860	if(!LOCAL_ACCESS(heap.data, 19LLU, 17LLU)/list*/)
104083	103861	{
104084		- state.addr = 18446744073709545544LLU; // 99999998fH'''''''''''''''
	103862	+ state.addr = 18446744073709545552LLU; // 99999998fP'''''''''''''''
104085	103863	break;
104086	103864	}
104087	103865	LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 19LLU, 17LLU)/list/, 4);

		@@ -104093,7 +103871,7 @@
104093	103871	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104094	103872	}
104095	103873	// 1LLU
104096		- uint64_t return_to = 18446744073709545542LLU;
	103874	+ uint64_t return_to = 18446744073709545550LLU;
104097	103875	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104098	103876	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104099	103877	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104102,12 +103880,12 @@
104102	103880	state.addr = 819859607768532676LLU; // resdest_$D
104103	103881	break;
104104	103882	}
104105		- case 18446744073709545542LLU: // 99999998fF'''''''''''''''
	103883	+ case 18446744073709545550LLU: // 99999998fN'''''''''''''''
104106	103884	{
104107		- state.addr = 18446744073709545543LLU; // 99999998fG'''''''''''''''
	103885	+ state.addr = 18446744073709545551LLU; // 99999998fO'''''''''''''''
104108	103886	break;
104109	103887	}
104110		- case 18446744073709545544LLU: // 99999998fH'''''''''''''''
	103888	+ case 18446744073709545552LLU: // 99999998fP'''''''''''''''
104111	103889	{
104112	103890	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
104113	103891	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 18

		@@ -104132,18 +103910,18 @@
104132	103910	// variable u64 finite____ goes out of scope
104133	103911	// emitted destructur for type u64
104134	103912	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference finite____ at 11
104135		- state.addr = 18446744073709545745LLU; // 99999998iQ'''''''''''''''
	103913	+ state.addr = 18446744073709545753LLU; // 99999998iY'''''''''''''''
104136	103914	break;
104137	103915	}
104138		- case 18446744073709545745LLU: // 99999998iQ'''''''''''''''
	103916	+ case 18446744073709545753LLU: // 99999998iY'''''''''''''''
104139	103917	{
104140	103918	// variable u64 isunion___ goes out of scope
104141	103919	// emitted destructur for type u64
104142	103920	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference isunion___ at 10
104143		- state.addr = 18446744073709545946LLU; // 99999998lZ'''''''''''''''
	103921	+ state.addr = 18446744073709545954LLU; // 99999998lg'''''''''''''''
104144	103922	break;
104145	103923	}
104146		- case 18446744073709545946LLU: // 99999998lZ'''''''''''''''
	103924	+ case 18446744073709545954LLU: // 99999998lg'''''''''''''''
104147	103925	{
104148	103926	// variable u64 isstruct__ goes out of scope
104149	103927	// emitted destructur for type u64

		@@ -104151,10 +103929,10 @@
104151	103929	// variable u64 id________ goes out of scope
104152	103930	// emitted destructur for type u64
104153	103931	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 8
104154		- state.addr = 18446744073709546060LLU; // 99999998nL'''''''''''''''
	103932	+ state.addr = 18446744073709546068LLU; // 99999998nT'''''''''''''''
104155	103933	break;
104156	103934	}
104157		- case 18446744073709546060LLU: // 99999998nL'''''''''''''''
	103935	+ case 18446744073709546068LLU: // 99999998nT'''''''''''''''
104158	103936	{
104159	103937	// variable u64 buf_______ goes out of scope
104160	103938	// emitted destructur for type u64

		@@ -104197,7 +103975,7 @@
104197	103975	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104198	103976	}
104199	103977	// 2LLU
104200		- uint64_t return_to = 18446744073709545540LLU;
	103978	+ uint64_t return_to = 18446744073709545548LLU;
104201	103979	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104202	103980	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104203	103981	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104206,24 +103984,24 @@
104206	103984	state.addr = 661671490923528192LLU; // isspace___
104207	103985	break;
104208	103986	}
104209		- case 18446744073709545540LLU: // 99999998fD'''''''''''''''
	103987	+ case 18446744073709545548LLU: // 99999998fL'''''''''''''''
104210	103988	{
104211		- state.addr = 18446744073709545541LLU; // 99999998fE'''''''''''''''
	103989	+ state.addr = 18446744073709545549LLU; // 99999998fM'''''''''''''''
104212	103990	break;
104213	103991	}
104214		- case 18446744073709545541LLU: // 99999998fE'''''''''''''''
	103992	+ case 18446744073709545549LLU: // 99999998fM'''''''''''''''
104215	103993	{
104216		- state.addr = /result0___/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545539LLU : 18446744073709545538LLU;
	103994	+ state.addr = /result0___/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545547LLU : 18446744073709545546LLU;
104217	103995	break;
104218	103996	}
104219		- case 18446744073709545539LLU: // 99999998fC'''''''''''''''
	103997	+ case 18446744073709545547LLU: // 99999998fK'''''''''''''''
104220	103998	{
104221	103999	heap.availilable_size_for_dynamic_objects += 0LLU;
104222	104000	heap.availilable_size_for_dynamic_objects += 0LLU;
104223		- state.addr = 18446744073709545537LLU; // 99999998fA'''''''''''''''
	104001	+ state.addr = 18446744073709545545LLU; // 99999998fI'''''''''''''''
104224	104002	break;
104225	104003	}
104226		- case 18446744073709545538LLU: // 99999998fB'''''''''''''''
	104004	+ case 18446744073709545546LLU: // 99999998fJ'''''''''''''''
104227	104005	{
104228	104006	{
104229	104007	uint64_t arg = 0LLU;

		@@ -104241,10 +104019,10 @@
104241	104019
104242	104020	/result1___/LOCAL_ACCESS(heap.data, 9LLU, 7LLU) = /result0___/LOCAL_ACCESS(heap.data, 9LLU, 6LLU) == /peek______/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU);
104243	104021	/result0___/LOCAL_ACCESS(heap.data, 9LLU, 6LLU) = /result0___/LOCAL_ACCESS(heap.data, 9LLU, 6LLU) && /result1___/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
104244		- state.addr = /result0___/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) ? 18446744073709545536LLU : 18446744073709545535LLU;
	104022	+ state.addr = /result0___/*LOCAL_ACCESS(heap.data, 9LLU, 6LLU) ? 18446744073709545544LLU : 18446744073709545543LLU;
104245	104023	break;
104246	104024	}
104247		- case 18446744073709545536LLU: // 99999998f_'''''''''''''''
	104025	+ case 18446744073709545544LLU: // 99999998fH'''''''''''''''
104248	104026	{
104249	104027	{
104250	104028	uint64_t mainresult = heap.data[0].elem0;

		@@ -104254,7 +104032,7 @@
104254	104032	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104255	104033	}
104256	104034	// 1LLU
104257		- uint64_t return_to = 18446744073709545533LLU;
	104035	+ uint64_t return_to = 18446744073709545541LLU;
104258	104036	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104259	104037	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104260	104038	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104263,19 +104041,19 @@
104263	104041	state.addr = 552432610005745664LLU; // comment___
104264	104042	break;
104265	104043	}
104266		- case 18446744073709545533LLU: // 99999998e7'''''''''''''''
	104044	+ case 18446744073709545541LLU: // 99999998fE'''''''''''''''
104267	104045	{
104268		- state.addr = 18446744073709545534LLU; // 99999998e8'''''''''''''''
	104046	+ state.addr = 18446744073709545542LLU; // 99999998fF'''''''''''''''
104269	104047	break;
104270	104048	}
104271		- case 18446744073709545534LLU: // 99999998e8'''''''''''''''
	104049	+ case 18446744073709545542LLU: // 99999998fF'''''''''''''''
104272	104050	{
104273	104051	heap.availilable_size_for_dynamic_objects += 0LLU;
104274	104052	heap.availilable_size_for_dynamic_objects += 0LLU;
104275		- state.addr = 18446744073709545532LLU; // 99999998e6'''''''''''''''
	104053	+ state.addr = 18446744073709545540LLU; // 99999998fD'''''''''''''''
104276	104054	break;
104277	104055	}
104278		- case 18446744073709545535LLU: // 99999998e9'''''''''''''''
	104056	+ case 18446744073709545543LLU: // 99999998fG'''''''''''''''
104279	104057	{
104280	104058	{
104281	104059	uint64_t mainresult = heap.data[0].elem0;

		@@ -104305,7 +104083,7 @@
104305	104083	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104306	104084	}
104307	104085	// 6LLU
104308		- uint64_t return_to = 18446744073709545530LLU;
	104086	+ uint64_t return_to = 18446744073709545538LLU;
104309	104087	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104310	104088	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104311	104089	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104314,17 +104092,17 @@
104314	104092	state.addr = 782701543332909056LLU; // parsedef__
104315	104093	break;
104316	104094	}
104317		- case 18446744073709545530LLU: // 99999998e4'''''''''''''''
	104095	+ case 18446744073709545538LLU: // 99999998fB'''''''''''''''
104318	104096	{
104319		- state.addr = 18446744073709545531LLU; // 99999998e5'''''''''''''''
	104097	+ state.addr = 18446744073709545539LLU; // 99999998fC'''''''''''''''
104320	104098	break;
104321	104099	}
104322		- case 18446744073709545531LLU: // 99999998e5'''''''''''''''
	104100	+ case 18446744073709545539LLU: // 99999998fC'''''''''''''''
104323	104101	{
104324		- state.addr = 18446744073709545532LLU; // 99999998e6'''''''''''''''
	104102	+ state.addr = 18446744073709545540LLU; // 99999998fD'''''''''''''''
104325	104103	break;
104326	104104	}
104327		- case 18446744073709545532LLU: // 99999998e6'''''''''''''''
	104105	+ case 18446744073709545540LLU: // 99999998fD'''''''''''''''
104328	104106	{
104329	104107	// variable u64 peek______ goes out of scope
104330	104108	// emitted destructur for type u64

		@@ -104332,10 +104110,10 @@
104332	104110	// variable u64 result1___ goes out of scope
104333	104111	// emitted destructur for type u64
104334	104112	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result1___ at 8
104335		- state.addr = 18446744073709545537LLU; // 99999998fA'''''''''''''''
	104113	+ state.addr = 18446744073709545545LLU; // 99999998fI'''''''''''''''
104336	104114	break;
104337	104115	}
104338		- case 18446744073709545537LLU: // 99999998fA'''''''''''''''
	104116	+ case 18446744073709545545LLU: // 99999998fI'''''''''''''''
104339	104117	{
104340	104118	// variable u64 result0___ goes out of scope
104341	104119	// emitted destructur for type u64

		@@ -104390,7 +104168,7 @@
104390	104168	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104391	104169	}
104392	104170	// 6LLU
104393		- uint64_t return_to = 18446744073709545528LLU;
	104171	+ uint64_t return_to = 18446744073709545536LLU;
104394	104172	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104395	104173	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104396	104174	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104399,22 +104177,22 @@
104399	104177	state.addr = 782701543332912000LLU; // parsedefs_
104400	104178	break;
104401	104179	}
104402		- case 18446744073709545528LLU: // 99999998e2'''''''''''''''
	104180	+ case 18446744073709545536LLU: // 99999998f_'''''''''''''''
104403	104181	{
104404		- state.addr = 18446744073709545529LLU; // 99999998e3'''''''''''''''
	104182	+ state.addr = 18446744073709545537LLU; // 99999998fA'''''''''''''''
104405	104183	break;
104406	104184	}
104407		- case 18446744073709545529LLU: // 99999998e3'''''''''''''''
	104185	+ case 18446744073709545537LLU: // 99999998fA'''''''''''''''
104408	104186	{
104409		- state.addr = 18446744073709545527LLU; // 99999998e1'''''''''''''''
	104187	+ state.addr = 18446744073709545535LLU; // 99999998e9'''''''''''''''
104410	104188	break;
104411	104189	}
104412		- case 18446744073709545527LLU: // 99999998e1'''''''''''''''
	104190	+ case 18446744073709545535LLU: // 99999998e9'''''''''''''''
104413	104191	{
104414	104192	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) = (uint64_t)getchar();
104415	104193	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) > 255)
104416	104194	{
104417		- state.addr = 18446744073709545526LLU; // 99999998e0'''''''''''''''
	104195	+ state.addr = 18446744073709545534LLU; // 99999998e8'''''''''''''''
104418	104196	break;
104419	104197	}
104420	104198	{

		@@ -104445,7 +104223,7 @@
104445	104223	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104446	104224	}
104447	104225	// 6LLU
104448		- uint64_t return_to = 18446744073709545524LLU;
	104226	+ uint64_t return_to = 18446744073709545532LLU;
104449	104227	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104450	104228	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104451	104229	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104454,17 +104232,17 @@
104454	104232	state.addr = 782701543332912000LLU; // parsedefs_
104455	104233	break;
104456	104234	}
104457		- case 18446744073709545524LLU: // 99999998ey'''''''''''''''
	104235	+ case 18446744073709545532LLU: // 99999998e6'''''''''''''''
104458	104236	{
104459		- state.addr = 18446744073709545525LLU; // 99999998ez'''''''''''''''
	104237	+ state.addr = 18446744073709545533LLU; // 99999998e7'''''''''''''''
104460	104238	break;
104461	104239	}
104462		- case 18446744073709545525LLU: // 99999998ez'''''''''''''''
	104240	+ case 18446744073709545533LLU: // 99999998e7'''''''''''''''
104463	104241	{
104464		- state.addr = 18446744073709545527LLU; // 99999998e1'''''''''''''''
	104242	+ state.addr = 18446744073709545535LLU; // 99999998e9'''''''''''''''
104465	104243	break;
104466	104244	}
104467		- case 18446744073709545526LLU: // 99999998e0'''''''''''''''
	104245	+ case 18446744073709545534LLU: // 99999998e8'''''''''''''''
104468	104246	{
104469	104247	// parameter-reference u64 lookahead_ goes out of scope
104470	104248	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference lookahead_ at 6

		@@ -104500,7 +104278,7 @@
104500	104278	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104501	104279	}
104502	104280	// 1LLU
104503		- uint64_t return_to = 18446744073709545521LLU;
	104281	+ uint64_t return_to = 18446744073709545529LLU;
104504	104282	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104505	104283	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104506	104284	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104509,12 +104287,12 @@
104509	104287	state.addr = 587881345921715008LLU; // emitenter_
104510	104288	break;
104511	104289	}
104512		- case 18446744073709545521LLU: // 99999998ev'''''''''''''''
	104290	+ case 18446744073709545529LLU: // 99999998e3'''''''''''''''
104513	104291	{
104514		- state.addr = 18446744073709545522LLU; // 99999998ew'''''''''''''''
	104292	+ state.addr = 18446744073709545530LLU; // 99999998e4'''''''''''''''
104515	104293	break;
104516	104294	}
104517		- case 18446744073709545522LLU: // 99999998ew'''''''''''''''
	104295	+ case 18446744073709545530LLU: // 99999998e4'''''''''''''''
104518	104296	{
104519	104297	fprintf(stdout, "%s", "\n fprintf(stderr, \"INTERNAL COMPILER ERROR: u64-destructor called instead of inlined\\n\");");
104520	104298	fprintf(stdout, "%s", "\n exit(-1);");

		@@ -104530,7 +104308,7 @@
104530	104308	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104531	104309	}
104532	104310	// 1LLU
104533		- uint64_t return_to = 18446744073709545518LLU;
	104311	+ uint64_t return_to = 18446744073709545526LLU;
104534	104312	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104535	104313	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104536	104314	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104539,28 +104317,28 @@
104539	104317	state.addr = 587881351406074923LLU; // emitjumpup
104540	104318	break;
104541	104319	}
104542		- case 18446744073709545518LLU: // 99999998es'''''''''''''''
	104320	+ case 18446744073709545526LLU: // 99999998e0'''''''''''''''
104543	104321	{
104544		- state.addr = 18446744073709545519LLU; // 99999998et'''''''''''''''
	104322	+ state.addr = 18446744073709545527LLU; // 99999998e1'''''''''''''''
104545	104323	break;
104546	104324	}
104547		- case 18446744073709545519LLU: // 99999998et'''''''''''''''
	104325	+ case 18446744073709545527LLU: // 99999998e1'''''''''''''''
104548	104326	{
104549	104327	// variable u64 level_____ goes out of scope
104550	104328	// emitted destructur for type u64
104551	104329	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 3
104552		- state.addr = 18446744073709545520LLU; // 99999998eu'''''''''''''''
	104330	+ state.addr = 18446744073709545528LLU; // 99999998e2'''''''''''''''
104553	104331	break;
104554	104332	}
104555		- case 18446744073709545520LLU: // 99999998eu'''''''''''''''
	104333	+ case 18446744073709545528LLU: // 99999998e2'''''''''''''''
104556	104334	{
104557	104335	// variable u64 id________ goes out of scope
104558	104336	// emitted destructur for type u64
104559	104337	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 2
104560		- state.addr = 18446744073709545523LLU; // 99999998ex'''''''''''''''
	104338	+ state.addr = 18446744073709545531LLU; // 99999998e5'''''''''''''''
104561	104339	break;
104562	104340	}
104563		- case 18446744073709545523LLU: // 99999998ex'''''''''''''''
	104341	+ case 18446744073709545531LLU: // 99999998e5'''''''''''''''
104564	104342	{
104565	104343	{
104566	104344	uint64_t arg = 712900180986300100LLU;

		@@ -104574,7 +104352,7 @@
104574	104352	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104575	104353	}
104576	104354	// 1LLU
104577		- uint64_t return_to = 18446744073709545515LLU;
	104355	+ uint64_t return_to = 18446744073709545523LLU;
104578	104356	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104579	104357	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104580	104358	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104583,12 +104361,12 @@
104583	104361	state.addr = 587881345921715008LLU; // emitenter_
104584	104362	break;
104585	104363	}
104586		- case 18446744073709545515LLU: // 99999998ep'''''''''''''''
	104364	+ case 18446744073709545523LLU: // 99999998ex'''''''''''''''
104587	104365	{
104588		- state.addr = 18446744073709545516LLU; // 99999998eq'''''''''''''''
	104366	+ state.addr = 18446744073709545524LLU; // 99999998ey'''''''''''''''
104589	104367	break;
104590	104368	}
104591		- case 18446744073709545516LLU: // 99999998eq'''''''''''''''
	104369	+ case 18446744073709545524LLU: // 99999998ey'''''''''''''''
104592	104370	{
104593	104371	fprintf(stdout, "%s", "\n fprintf(stderr, \"INTERNAL COMPILER ERROR: list-destructor called instead of inlined\\n\");");
104594	104372	fprintf(stdout, "%s", "\n exit(-1);");

		@@ -104604,7 +104382,7 @@
104604	104382	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104605	104383	}
104606	104384	// 1LLU
104607		- uint64_t return_to = 18446744073709545512LLU;
	104385	+ uint64_t return_to = 18446744073709545520LLU;
104608	104386	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104609	104387	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104610	104388	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104613,28 +104391,28 @@
104613	104391	state.addr = 587881351406074923LLU; // emitjumpup
104614	104392	break;
104615	104393	}
104616		- case 18446744073709545512LLU: // 99999998em'''''''''''''''
	104394	+ case 18446744073709545520LLU: // 99999998eu'''''''''''''''
104617	104395	{
104618		- state.addr = 18446744073709545513LLU; // 99999998en'''''''''''''''
	104396	+ state.addr = 18446744073709545521LLU; // 99999998ev'''''''''''''''
104619	104397	break;
104620	104398	}
104621		- case 18446744073709545513LLU: // 99999998en'''''''''''''''
	104399	+ case 18446744073709545521LLU: // 99999998ev'''''''''''''''
104622	104400	{
104623	104401	// variable u64 level_____ goes out of scope
104624	104402	// emitted destructur for type u64
104625	104403	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 3
104626		- state.addr = 18446744073709545514LLU; // 99999998eo'''''''''''''''
	104404	+ state.addr = 18446744073709545522LLU; // 99999998ew'''''''''''''''
104627	104405	break;
104628	104406	}
104629		- case 18446744073709545514LLU: // 99999998eo'''''''''''''''
	104407	+ case 18446744073709545522LLU: // 99999998ew'''''''''''''''
104630	104408	{
104631	104409	// variable u64 id________ goes out of scope
104632	104410	// emitted destructur for type u64
104633	104411	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 2
104634		- state.addr = 18446744073709545517LLU; // 99999998er'''''''''''''''
	104412	+ state.addr = 18446744073709545525LLU; // 99999998ez'''''''''''''''
104635	104413	break;
104636	104414	}
104637		- case 18446744073709545517LLU: // 99999998er'''''''''''''''
	104415	+ case 18446744073709545525LLU: // 99999998ez'''''''''''''''
104638	104416	{
104639	104417	// parameter-reference u64 tmpaddr___ goes out of scope
104640	104418	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpaddr___ at 1

		@@ -104661,7 +104439,7 @@
104661	104439	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104662	104440	}
104663	104441	// 1LLU
104664		- uint64_t return_to = 18446744073709545510LLU;
	104442	+ uint64_t return_to = 18446744073709545518LLU;
104665	104443	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104666	104444	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104667	104445	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104670,12 +104448,12 @@
104670	104448	state.addr = 839519719621918720LLU; // skipws____
104671	104449	break;
104672	104450	}
104673		- case 18446744073709545510LLU: // 99999998ek'''''''''''''''
	104451	+ case 18446744073709545518LLU: // 99999998es'''''''''''''''
104674	104452	{
104675		- state.addr = 18446744073709545511LLU; // 99999998el'''''''''''''''
	104453	+ state.addr = 18446744073709545519LLU; // 99999998et'''''''''''''''
104676	104454	break;
104677	104455	}
104678		- case 18446744073709545511LLU: // 99999998el'''''''''''''''
	104456	+ case 18446744073709545519LLU: // 99999998et'''''''''''''''
104679	104457	{
104680	104458	{
104681	104459	uint64_t arg = 96LLU;

		@@ -104686,35 +104464,35 @@
104686	104464	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
104687	104465	}
104688	104466	/toggle_ext/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /sym_______/LOCAL_ACCESS(heap.data, 4LLU, 2LLU) == /c_________/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
104689		- state.addr = /toggle_ext/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545508LLU : 18446744073709545507LLU;
	104467	+ state.addr = /toggle_ext/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545516LLU : 18446744073709545515LLU;
104690	104468	break;
104691	104469	}
104692		- case 18446744073709545508LLU: // 99999998ei'''''''''''''''
	104470	+ case 18446744073709545516LLU: // 99999998eq'''''''''''''''
104693	104471	{
104694		- state.addr = 18446744073709545506LLU; // 99999998eg'''''''''''''''
	104472	+ state.addr = 18446744073709545514LLU; // 99999998eo'''''''''''''''
104695	104473	break;
104696	104474	}
104697		- case 18446744073709545506LLU: // 99999998eg'''''''''''''''
	104475	+ case 18446744073709545514LLU: // 99999998eo'''''''''''''''
104698	104476	{
104699	104477	*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = (uint64_t)getchar();
104700	104478	if(!LOCAL_ACCESS(heap.data, 4LLU, 1LLU) \|\| LOCAL_ACCESS(heap.data, 4LLU, 1LLU) > 255)
104701	104479	{
104702		- state.addr = 18446744073709545505LLU; // 99999998ef'''''''''''''''
	104480	+ state.addr = 18446744073709545513LLU; // 99999998en'''''''''''''''
104703	104481	break;
104704	104482	}
104705	104483	/toggle_ext/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /sym_______/LOCAL_ACCESS(heap.data, 4LLU, 2LLU) == /c_________/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
104706		- state.addr = /toggle_ext/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545504LLU : 18446744073709545503LLU;
	104484	+ state.addr = /toggle_ext/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709545512LLU : 18446744073709545511LLU;
104707	104485	break;
104708	104486	}
104709		- case 18446744073709545504LLU: // 99999998ee'''''''''''''''
	104487	+ case 18446744073709545512LLU: // 99999998em'''''''''''''''
104710	104488	{
104711	104489	ungetc(0, stdin);
104712	104490	heap.availilable_size_for_dynamic_objects += 0LLU;
104713	104491	heap.availilable_size_for_dynamic_objects += 0LLU;
104714		- state.addr = 18446744073709545502LLU; // 99999998ec'''''''''''''''
	104492	+ state.addr = 18446744073709545510LLU; // 99999998ek'''''''''''''''
104715	104493	break;
104716	104494	}
104717		- case 18446744073709545503LLU: // 99999998ed'''''''''''''''
	104495	+ case 18446744073709545511LLU: // 99999998el'''''''''''''''
104718	104496	{
104719	104497	{
104720	104498	uint64_t mainresult = heap.data[0].elem0;

		@@ -104724,7 +104502,7 @@
104724	104502	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104725	104503	}
104726	104504	// 1LLU
104727		- uint64_t return_to = 18446744073709545500LLU;
	104505	+ uint64_t return_to = 18446744073709545508LLU;
104728	104506	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104729	104507	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104730	104508	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104733,28 +104511,28 @@
104733	104511	state.addr = 587881343588366336LLU; // emitccode_
104734	104512	break;
104735	104513	}
104736		- case 18446744073709545500LLU: // 99999998ea'''''''''''''''
	104514	+ case 18446744073709545508LLU: // 99999998ei'''''''''''''''
104737	104515	{
104738		- state.addr = 18446744073709545501LLU; // 99999998eb'''''''''''''''
	104516	+ state.addr = 18446744073709545509LLU; // 99999998ej'''''''''''''''
104739	104517	break;
104740	104518	}
104741		- case 18446744073709545501LLU: // 99999998eb'''''''''''''''
	104519	+ case 18446744073709545509LLU: // 99999998ej'''''''''''''''
104742	104520	{
104743		- state.addr = 18446744073709545502LLU; // 99999998ec'''''''''''''''
	104521	+ state.addr = 18446744073709545510LLU; // 99999998ek'''''''''''''''
104744	104522	break;
104745	104523	}
104746		- case 18446744073709545502LLU: // 99999998ec'''''''''''''''
	104524	+ case 18446744073709545510LLU: // 99999998ek'''''''''''''''
104747	104525	{
104748		- state.addr = 18446744073709545506LLU; // 99999998eg'''''''''''''''
	104526	+ state.addr = 18446744073709545514LLU; // 99999998eo'''''''''''''''
104749	104527	break;
104750	104528	}
104751		- case 18446744073709545505LLU: // 99999998ef'''''''''''''''
	104529	+ case 18446744073709545513LLU: // 99999998en'''''''''''''''
104752	104530	{
104753	104531	/c_________/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = (uint64_t)getchar();
104754		- state.addr = 18446744073709545507LLU; // 99999998eh'''''''''''''''
	104532	+ state.addr = 18446744073709545515LLU; // 99999998ep'''''''''''''''
104755	104533	break;
104756	104534	}
104757		- case 18446744073709545507LLU: // 99999998eh'''''''''''''''
	104535	+ case 18446744073709545515LLU: // 99999998ep'''''''''''''''
104758	104536	{
104759	104537	// variable u64 toggle_ext goes out of scope
104760	104538	// emitted destructur for type u64

		@@ -104762,10 +104540,10 @@
104762	104540	// variable u64 sym_______ goes out of scope
104763	104541	// emitted destructur for type u64
104764	104542	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 3
104765		- state.addr = 18446744073709545509LLU; // 99999998ej'''''''''''''''
	104543	+ state.addr = 18446744073709545517LLU; // 99999998er'''''''''''''''
104766	104544	break;
104767	104545	}
104768		- case 18446744073709545509LLU: // 99999998ej'''''''''''''''
	104546	+ case 18446744073709545517LLU: // 99999998er'''''''''''''''
104769	104547	{
104770	104548	{
104771	104549	uint64_t mainresult = heap.data[0].elem0;

		@@ -104775,7 +104553,7 @@
104775	104553	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104776	104554	}
104777	104555	// 1LLU
104778		- uint64_t return_to = 18446744073709545498LLU;
	104556	+ uint64_t return_to = 18446744073709545506LLU;
104779	104557	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104780	104558	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104781	104559	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104784,12 +104562,12 @@
104784	104562	state.addr = 839519719621918720LLU; // skipws____
104785	104563	break;
104786	104564	}
104787		- case 18446744073709545498LLU: // 99999998eZ'''''''''''''''
	104565	+ case 18446744073709545506LLU: // 99999998eg'''''''''''''''
104788	104566	{
104789		- state.addr = 18446744073709545499LLU; // 99999998e$'''''''''''''''
	104567	+ state.addr = 18446744073709545507LLU; // 99999998eh'''''''''''''''
104790	104568	break;
104791	104569	}
104792		- case 18446744073709545499LLU: // 99999998e$'''''''''''''''
	104570	+ case 18446744073709545507LLU: // 99999998eh'''''''''''''''
104793	104571	{
104794	104572	{
104795	104573	uint64_t mainresult = heap.data[0].elem0;

		@@ -104799,7 +104577,7 @@
104799	104577	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104800	104578	}
104801	104579	// 1LLU
104802		- uint64_t return_to = 18446744073709545496LLU;
	104580	+ uint64_t return_to = 18446744073709545504LLU;
104803	104581	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104804	104582	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104805	104583	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104808,12 +104586,12 @@
104808	104586	state.addr = 552432610005975040LLU; // comment2__
104809	104587	break;
104810	104588	}
104811		- case 18446744073709545496LLU: // 99999998eX'''''''''''''''
	104589	+ case 18446744073709545504LLU: // 99999998ee'''''''''''''''
104812	104590	{
104813		- state.addr = 18446744073709545497LLU; // 99999998eY'''''''''''''''
	104591	+ state.addr = 18446744073709545505LLU; // 99999998ef'''''''''''''''
104814	104592	break;
104815	104593	}
104816		- case 18446744073709545497LLU: // 99999998eY'''''''''''''''
	104594	+ case 18446744073709545505LLU: // 99999998ef'''''''''''''''
104817	104595	{
104818	104596	{
104819	104597	uint64_t mainresult = heap.data[0].elem0;

		@@ -104823,7 +104601,7 @@
104823	104601	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104824	104602	}
104825	104603	// 1LLU
104826		- uint64_t return_to = 18446744073709545494LLU;
	104604	+ uint64_t return_to = 18446744073709545502LLU;
104827	104605	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104828	104606	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104829	104607	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104832,12 +104610,12 @@
104832	104610	state.addr = 839519719621918720LLU; // skipws____
104833	104611	break;
104834	104612	}
104835		- case 18446744073709545494LLU: // 99999998eV'''''''''''''''
	104613	+ case 18446744073709545502LLU: // 99999998ec'''''''''''''''
104836	104614	{
104837		- state.addr = 18446744073709545495LLU; // 99999998eW'''''''''''''''
	104615	+ state.addr = 18446744073709545503LLU; // 99999998ed'''''''''''''''
104838	104616	break;
104839	104617	}
104840		- case 18446744073709545495LLU: // 99999998eW'''''''''''''''
	104618	+ case 18446744073709545503LLU: // 99999998ed'''''''''''''''
104841	104619	{
104842	104620	matchid("memory", &/c_________/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
104843	104621	{

		@@ -104848,7 +104626,7 @@
104848	104626	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104849	104627	}
104850	104628	// 1LLU
104851		- uint64_t return_to = 18446744073709545492LLU;
	104629	+ uint64_t return_to = 18446744073709545500LLU;
104852	104630	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104853	104631	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104854	104632	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104857,12 +104635,12 @@
104857	104635	state.addr = 839519719621918720LLU; // skipws____
104858	104636	break;
104859	104637	}
104860		- case 18446744073709545492LLU: // 99999998eT'''''''''''''''
	104638	+ case 18446744073709545500LLU: // 99999998ea'''''''''''''''
104861	104639	{
104862		- state.addr = 18446744073709545493LLU; // 99999998eU'''''''''''''''
	104640	+ state.addr = 18446744073709545501LLU; // 99999998eb'''''''''''''''
104863	104641	break;
104864	104642	}
104865		- case 18446744073709545493LLU: // 99999998eU'''''''''''''''
	104643	+ case 18446744073709545501LLU: // 99999998eb'''''''''''''''
104866	104644	{
104867	104645	matchid("=", &/c_________/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
104868	104646	{

		@@ -104873,7 +104651,7 @@
104873	104651	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104874	104652	}
104875	104653	// 1LLU
104876		- uint64_t return_to = 18446744073709545490LLU;
	104654	+ uint64_t return_to = 18446744073709545498LLU;
104877	104655	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104878	104656	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104879	104657	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104882,12 +104660,12 @@
104882	104660	state.addr = 839519719621918720LLU; // skipws____
104883	104661	break;
104884	104662	}
104885		- case 18446744073709545490LLU: // 99999998eR'''''''''''''''
	104663	+ case 18446744073709545498LLU: // 99999998eZ'''''''''''''''
104886	104664	{
104887		- state.addr = 18446744073709545491LLU; // 99999998eS'''''''''''''''
	104665	+ state.addr = 18446744073709545499LLU; // 99999998e$'''''''''''''''
104888	104666	break;
104889	104667	}
104890		- case 18446744073709545491LLU: // 99999998eS'''''''''''''''
	104668	+ case 18446744073709545499LLU: // 99999998e$'''''''''''''''
104891	104669	{
104892	104670	{
104893	104671	uint64_t arg = 0LLU;

		@@ -104902,7 +104680,7 @@
104902	104680	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104903	104681	}
104904	104682	// 1LLU
104905		- uint64_t return_to = 18446744073709545488LLU;
	104683	+ uint64_t return_to = 18446744073709545496LLU;
104906	104684	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104907	104685	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104908	104686	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104911,12 +104689,12 @@
104911	104689	state.addr = 839519719621918720LLU; // skipws____
104912	104690	break;
104913	104691	}
104914		- case 18446744073709545488LLU: // 99999998eP'''''''''''''''
	104692	+ case 18446744073709545496LLU: // 99999998eX'''''''''''''''
104915	104693	{
104916		- state.addr = 18446744073709545489LLU; // 99999998eQ'''''''''''''''
	104694	+ state.addr = 18446744073709545497LLU; // 99999998eY'''''''''''''''
104917	104695	break;
104918	104696	}
104919		- case 18446744073709545489LLU: // 99999998eQ'''''''''''''''
	104697	+ case 18446744073709545497LLU: // 99999998eY'''''''''''''''
104920	104698	{
104921	104699	{
104922	104700	uint64_t arg = 0LLU;

		@@ -104929,7 +104707,7 @@
104929	104707	uint64_t mainresult = heap.data[0].elem0;
104930	104708	heap.data[0].elem0 = 0;
104931	104709	// 0LLU
104932		- uint64_t return_to = 18446744073709545486LLU;
	104710	+ uint64_t return_to = 18446744073709545494LLU;
104933	104711	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104934	104712	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104935	104713	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104938,12 +104716,12 @@
104938	104716	state.addr = 660268666046119936LLU; // intro_____
104939	104717	break;
104940	104718	}
104941		- case 18446744073709545486LLU: // 99999998eN'''''''''''''''
	104719	+ case 18446744073709545494LLU: // 99999998eV'''''''''''''''
104942	104720	{
104943		- state.addr = 18446744073709545487LLU; // 99999998eO'''''''''''''''
	104721	+ state.addr = 18446744073709545495LLU; // 99999998eW'''''''''''''''
104944	104722	break;
104945	104723	}
104946		- case 18446744073709545487LLU: // 99999998eO'''''''''''''''
	104724	+ case 18446744073709545495LLU: // 99999998eW'''''''''''''''
104947	104725	{
104948	104726	{
104949	104727	uint64_t arg = 0LLU;

		@@ -104965,7 +104743,7 @@
104965	104743	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
104966	104744	}
104967	104745	// 2LLU
104968		- uint64_t return_to = 18446744073709545484LLU;
	104746	+ uint64_t return_to = 18446744073709545492LLU;
104969	104747	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
104970	104748	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
104971	104749	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -104974,12 +104752,12 @@
104974	104752	state.addr = 517555828430075934LLU; // assign_dec
104975	104753	break;
104976	104754	}
104977		- case 18446744073709545484LLU: // 99999998eL'''''''''''''''
	104755	+ case 18446744073709545492LLU: // 99999998eT'''''''''''''''
104978	104756	{
104979		- state.addr = 18446744073709545485LLU; // 99999998eM'''''''''''''''
	104757	+ state.addr = 18446744073709545493LLU; // 99999998eU'''''''''''''''
104980	104758	break;
104981	104759	}
104982		- case 18446744073709545485LLU: // 99999998eM'''''''''''''''
	104760	+ case 18446744073709545493LLU: // 99999998eU'''''''''''''''
104983	104761	{
104984	104762	{
104985	104763	uint64_t arg = 0LLU;

		@@ -105008,7 +104786,7 @@
105008	104786	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105009	104787	}
105010	104788	// 1LLU
105011		- uint64_t return_to = 18446744073709545482LLU;
	104789	+ uint64_t return_to = 18446744073709545490LLU;
105012	104790	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105013	104791	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105014	104792	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105017,12 +104795,12 @@
105017	104795	state.addr = 787446708198178816LLU; // printnr___
105018	104796	break;
105019	104797	}
105020		- case 18446744073709545482LLU: // 99999998eJ'''''''''''''''
	104798	+ case 18446744073709545490LLU: // 99999998eR'''''''''''''''
105021	104799	{
105022		- state.addr = 18446744073709545483LLU; // 99999998eK'''''''''''''''
	104800	+ state.addr = 18446744073709545491LLU; // 99999998eS'''''''''''''''
105023	104801	break;
105024	104802	}
105025		- case 18446744073709545483LLU: // 99999998eK'''''''''''''''
	104803	+ case 18446744073709545491LLU: // 99999998eS'''''''''''''''
105026	104804	{
105027	104805	fprintf(stdout, "%s", " + 1)");
105028	104806	fprintf(stdout, "%s", "\n struct pair heapraw[");

		@@ -105034,7 +104812,7 @@
105034	104812	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105035	104813	}
105036	104814	// 1LLU
105037		- uint64_t return_to = 18446744073709545480LLU;
	104815	+ uint64_t return_to = 18446744073709545488LLU;
105038	104816	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105039	104817	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105040	104818	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105043,12 +104821,12 @@
105043	104821	state.addr = 787446708198178816LLU; // printnr___
105044	104822	break;
105045	104823	}
105046		- case 18446744073709545480LLU: // 99999998eH'''''''''''''''
	104824	+ case 18446744073709545488LLU: // 99999998eP'''''''''''''''
105047	104825	{
105048		- state.addr = 18446744073709545481LLU; // 99999998eI'''''''''''''''
	104826	+ state.addr = 18446744073709545489LLU; // 99999998eQ'''''''''''''''
105049	104827	break;
105050	104828	}
105051		- case 18446744073709545481LLU: // 99999998eI'''''''''''''''
	104829	+ case 18446744073709545489LLU: // 99999998eQ'''''''''''''''
105052	104830	{
105053	104831	fprintf(stdout, "%s", " + 1];");
105054	104832	fprintf(stdout, "%s", "\n struct all all = init(heapraw);");

		@@ -105066,7 +104844,7 @@
105066	104844	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105067	104845	}
105068	104846	// 1LLU
105069		- uint64_t return_to = 18446744073709545478LLU;
	104847	+ uint64_t return_to = 18446744073709545486LLU;
105070	104848	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105071	104849	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105072	104850	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105075,12 +104853,12 @@
105075	104853	state.addr = 536089416471863296LLU; // builtins__
105076	104854	break;
105077	104855	}
105078		- case 18446744073709545478LLU: // 99999998eF'''''''''''''''
	104856	+ case 18446744073709545486LLU: // 99999998eN'''''''''''''''
105079	104857	{
105080		- state.addr = 18446744073709545479LLU; // 99999998eG'''''''''''''''
	104858	+ state.addr = 18446744073709545487LLU; // 99999998eO'''''''''''''''
105081	104859	break;
105082	104860	}
105083		- case 18446744073709545479LLU: // 99999998eG'''''''''''''''
	104861	+ case 18446744073709545487LLU: // 99999998eO'''''''''''''''
105084	104862	{
105085	104863	{
105086	104864	uint64_t arg = 0LLU;

		@@ -105114,7 +104892,7 @@
105114	104892	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105115	104893	}
105116	104894	// 6LLU
105117		- uint64_t return_to = 18446744073709545475LLU;
	104895	+ uint64_t return_to = 18446744073709545483LLU;
105118	104896	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105119	104897	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105120	104898	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105123,12 +104901,12 @@
105123	104901	state.addr = 782701543537682560LLU; // parseprog_
105124	104902	break;
105125	104903	}
105126		- case 18446744073709545475LLU: // 99999998eC'''''''''''''''
	104904	+ case 18446744073709545483LLU: // 99999998eK'''''''''''''''
105127	104905	{
105128		- state.addr = 18446744073709545476LLU; // 99999998eD'''''''''''''''
	104906	+ state.addr = 18446744073709545484LLU; // 99999998eL'''''''''''''''
105129	104907	break;
105130	104908	}
105131		- case 18446744073709545476LLU: // 99999998eD'''''''''''''''
	104909	+ case 18446744073709545484LLU: // 99999998eL'''''''''''''''
105132	104910	{
105133	104911	// variable list<block_____> blocklist_ goes out of scope
105134	104912	// emitted destructur for type list<block_____>

		@@ -105137,14 +104915,14 @@
105137	104915	uint64_t arg = 0;
105138	104916	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
105139	104917	}
105140		- state.addr = 18446744073709545473LLU; // 99999998eA'''''''''''''''
	104918	+ state.addr = 18446744073709545481LLU; // 99999998eI'''''''''''''''
105141	104919	break;
105142	104920	}
105143		- case 18446744073709545473LLU: // 99999998eA'''''''''''''''
	104921	+ case 18446744073709545481LLU: // 99999998eI'''''''''''''''
105144	104922	{
105145	104923	if(!LOCAL_ACCESS(heap.data, 12LLU, 10LLU)/list*/)
105146	104924	{
105147		- state.addr = 18446744073709545474LLU; // 99999998eB'''''''''''''''
	104925	+ state.addr = 18446744073709545482LLU; // 99999998eJ'''''''''''''''
105148	104926	break;
105149	104927	}
105150	104928	LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 12LLU, 10LLU)/list/, 8);

		@@ -105156,7 +104934,7 @@
105156	104934	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105157	104935	}
105158	104936	// 1LLU
105159		- uint64_t return_to = 18446744073709545472LLU;
	104937	+ uint64_t return_to = 18446744073709545480LLU;
105160	104938	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105161	104939	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105162	104940	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105165,19 +104943,19 @@
105165	104943	state.addr = 533581901206652612LLU; // block___$D
105166	104944	break;
105167	104945	}
105168		- case 18446744073709545472LLU: // 99999998e_'''''''''''''''
	104946	+ case 18446744073709545480LLU: // 99999998eH'''''''''''''''
105169	104947	{
105170		- state.addr = 18446744073709545473LLU; // 99999998eA'''''''''''''''
	104948	+ state.addr = 18446744073709545481LLU; // 99999998eI'''''''''''''''
105171	104949	break;
105172	104950	}
105173		- case 18446744073709545474LLU: // 99999998eB'''''''''''''''
	104951	+ case 18446744073709545482LLU: // 99999998eJ'''''''''''''''
105174	104952	{
105175	104953	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
105176	104954	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference blocklist_ at 11
105177		- state.addr = 18446744073709545477LLU; // 99999998eE'''''''''''''''
	104955	+ state.addr = 18446744073709545485LLU; // 99999998eM'''''''''''''''
105178	104956	break;
105179	104957	}
105180		- case 18446744073709545477LLU: // 99999998eE'''''''''''''''
	104958	+ case 18446744073709545485LLU: // 99999998eM'''''''''''''''
105181	104959	{
105182	104960	{
105183	104961	uint64_t arg = 0LLU;

		@@ -105219,7 +104997,7 @@
105219	104997	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105220	104998	}
105221	104999	// 6LLU
105222		- uint64_t return_to = 18446744073709545470LLU;
	105000	+ uint64_t return_to = 18446744073709545478LLU;
105223	105001	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105224	105002	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105225	105003	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105228,12 +105006,12 @@
105228	105006	state.addr = 587881350213857280LLU; // emitinit__
105229	105007	break;
105230	105008	}
105231		- case 18446744073709545470LLU: // 99999998d8'''''''''''''''
	105009	+ case 18446744073709545478LLU: // 99999998eF'''''''''''''''
105232	105010	{
105233		- state.addr = 18446744073709545471LLU; // 99999998d9'''''''''''''''
	105011	+ state.addr = 18446744073709545479LLU; // 99999998eG'''''''''''''''
105234	105012	break;
105235	105013	}
105236		- case 18446744073709545471LLU: // 99999998d9'''''''''''''''
	105014	+ case 18446744073709545479LLU: // 99999998eG'''''''''''''''
105237	105015	{
105238	105016	{
105239	105017	uint64_t mainresult = heap.data[0].elem0;

		@@ -105243,7 +105021,7 @@
105243	105021	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105244	105022	}
105245	105023	// 1LLU
105246		- uint64_t return_to = 18446744073709545468LLU;
	105024	+ uint64_t return_to = 18446744073709545476LLU;
105247	105025	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105248	105026	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105249	105027	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105252,12 +105030,12 @@
105252	105030	state.addr = 587881345921715008LLU; // emitenter_
105253	105031	break;
105254	105032	}
105255		- case 18446744073709545468LLU: // 99999998d6'''''''''''''''
	105033	+ case 18446744073709545476LLU: // 99999998eD'''''''''''''''
105256	105034	{
105257		- state.addr = 18446744073709545469LLU; // 99999998d7'''''''''''''''
	105035	+ state.addr = 18446744073709545477LLU; // 99999998eE'''''''''''''''
105258	105036	break;
105259	105037	}
105260		- case 18446744073709545469LLU: // 99999998d7'''''''''''''''
	105038	+ case 18446744073709545477LLU: // 99999998eE'''''''''''''''
105261	105039	{
105262	105040	fprintf(stdout, "%s", "\n // program starts here with call into main");
105263	105041	{

		@@ -105280,7 +105058,7 @@
105280	105058	uint64_t mainresult = heap.data[0].elem0;
105281	105059	heap.data[0].elem0 = 0;
105282	105060	// 0LLU
105283		- uint64_t return_to = 18446744073709545465LLU;
	105061	+ uint64_t return_to = 18446744073709545473LLU;
105284	105062	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105285	105063	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105286	105064	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105289,12 +105067,12 @@
105289	105067	state.addr = 548487490190330432LLU; // callbegin_
105290	105068	break;
105291	105069	}
105292		- case 18446744073709545465LLU: // 99999998d3'''''''''''''''
	105070	+ case 18446744073709545473LLU: // 99999998eA'''''''''''''''
105293	105071	{
105294		- state.addr = 18446744073709545466LLU; // 99999998d4'''''''''''''''
	105072	+ state.addr = 18446744073709545474LLU; // 99999998eB'''''''''''''''
105295	105073	break;
105296	105074	}
105297		- case 18446744073709545466LLU: // 99999998d4'''''''''''''''
	105075	+ case 18446744073709545474LLU: // 99999998eB'''''''''''''''
105298	105076	{
105299	105077	{
105300	105078	uint64_t arg = 1LLU;

		@@ -105332,7 +105110,7 @@
105332	105110	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105333	105111	}
105334	105112	// 6LLU
105335		- uint64_t return_to = 18446744073709545463LLU;
	105113	+ uint64_t return_to = 18446744073709545471LLU;
105336	105114	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105337	105115	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105338	105116	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105341,12 +105119,12 @@
105341	105119	state.addr = 517221173180428288LLU; // argconst__
105342	105120	break;
105343	105121	}
105344		- case 18446744073709545463LLU: // 99999998d1'''''''''''''''
	105122	+ case 18446744073709545471LLU: // 99999998d9'''''''''''''''
105345	105123	{
105346		- state.addr = 18446744073709545464LLU; // 99999998d2'''''''''''''''
	105124	+ state.addr = 18446744073709545472LLU; // 99999998e_'''''''''''''''
105347	105125	break;
105348	105126	}
105349		- case 18446744073709545464LLU: // 99999998d2'''''''''''''''
	105127	+ case 18446744073709545472LLU: // 99999998e_'''''''''''''''
105350	105128	{
105351	105129	{
105352	105130	uint64_t mainresult = heap.data[0].elem0;

		@@ -105372,7 +105150,7 @@
105372	105150	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105373	105151	}
105374	105152	// 5LLU
105375		- uint64_t return_to = 18446744073709545461LLU;
	105153	+ uint64_t return_to = 18446744073709545469LLU;
105376	105154	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105377	105155	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105378	105156	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105381,12 +105159,12 @@
105381	105159	state.addr = 548487493561614336LLU; // callend___
105382	105160	break;
105383	105161	}
105384		- case 18446744073709545461LLU: // 99999998dz'''''''''''''''
	105162	+ case 18446744073709545469LLU: // 99999998d7'''''''''''''''
105385	105163	{
105386		- state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
	105164	+ state.addr = 18446744073709545470LLU; // 99999998d8'''''''''''''''
105387	105165	break;
105388	105166	}
105389		- case 18446744073709545462LLU: // 99999998d0'''''''''''''''
	105167	+ case 18446744073709545470LLU: // 99999998d8'''''''''''''''
105390	105168	{
105391	105169	fprintf(stdout, "%s", "\n fprintf(stderr, \"INTERNAL ERROR: 0-instruction-address\\n\"); // this should never be reached");
105392	105170	fprintf(stdout, "%s", "\n exit(-1);");

		@@ -105415,7 +105193,7 @@
105415	105193	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105416	105194	}
105417	105195	// 4LLU
105418		- uint64_t return_to = 18446744073709545458LLU;
	105196	+ uint64_t return_to = 18446744073709545466LLU;
105419	105197	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105420	105198	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105421	105199	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105424,20 +105202,20 @@
105424	105202	state.addr = 587881357748664875LLU; // emitpoptmp
105425	105203	break;
105426	105204	}
105427		- case 18446744073709545458LLU: // 99999998dw'''''''''''''''
	105205	+ case 18446744073709545466LLU: // 99999998d4'''''''''''''''
105428	105206	{
105429		- state.addr = 18446744073709545459LLU; // 99999998dx'''''''''''''''
	105207	+ state.addr = 18446744073709545467LLU; // 99999998d5'''''''''''''''
105430	105208	break;
105431	105209	}
105432		- case 18446744073709545459LLU: // 99999998dx'''''''''''''''
	105210	+ case 18446744073709545467LLU: // 99999998d5'''''''''''''''
105433	105211	{
105434	105212	// variable u64 level_____ goes out of scope
105435	105213	// emitted destructur for type u64
105436	105214	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference level_____ at 20
105437		- state.addr = 18446744073709545460LLU; // 99999998dy'''''''''''''''
	105215	+ state.addr = 18446744073709545468LLU; // 99999998d6'''''''''''''''
105438	105216	break;
105439	105217	}
105440		- case 18446744073709545460LLU: // 99999998dy'''''''''''''''
	105218	+ case 18446744073709545468LLU: // 99999998d6'''''''''''''''
105441	105219	{
105442	105220	{
105443	105221	uint64_t mainresult = heap.data[0].elem0;

		@@ -105455,7 +105233,7 @@
105455	105233	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105456	105234	}
105457	105235	// 3LLU
105458		- uint64_t return_to = 18446744073709545456LLU;
	105236	+ uint64_t return_to = 18446744073709545464LLU;
105459	105237	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105460	105238	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105461	105239	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105464,12 +105242,12 @@
105464	105242	state.addr = 587881353282000896LLU; // emitleave_
105465	105243	break;
105466	105244	}
105467		- case 18446744073709545456LLU: // 99999998du'''''''''''''''
	105245	+ case 18446744073709545464LLU: // 99999998d2'''''''''''''''
105468	105246	{
105469		- state.addr = 18446744073709545457LLU; // 99999998dv'''''''''''''''
	105247	+ state.addr = 18446744073709545465LLU; // 99999998d3'''''''''''''''
105470	105248	break;
105471	105249	}
105472		- case 18446744073709545457LLU: // 99999998dv'''''''''''''''
	105250	+ case 18446744073709545465LLU: // 99999998d3'''''''''''''''
105473	105251	{
105474	105252	// variable u64 resultaddr goes out of scope
105475	105253	// emitted destructur for type u64

		@@ -105489,10 +105267,10 @@
105489	105267	// variable u64 outside___ goes out of scope
105490	105268	// emitted destructur for type u64
105491	105269	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference outside___ at 14
105492		- state.addr = 18446744073709545467LLU; // 99999998d5'''''''''''''''
	105270	+ state.addr = 18446744073709545475LLU; // 99999998eC'''''''''''''''
105493	105271	break;
105494	105272	}
105495		- case 18446744073709545467LLU: // 99999998d5'''''''''''''''
	105273	+ case 18446744073709545475LLU: // 99999998eC'''''''''''''''
105496	105274	{
105497	105275	fprintf(stdout, "%s", "\n default:");
105498	105276	fprintf(stdout, "%s", "\n {");

		@@ -105506,10 +105284,10 @@
105506	105284	fprintf(stdout, "%s", "\n");
105507	105285	fprintf(stdout, "%s", "\n uint64_t main_result = heap.data[0].elem0;");
105508	105286	fprintf(stdout, "%s", "\n");
105509		- state.addr = 18446744073709545455LLU; // 99999998dt'''''''''''''''
	105287	+ state.addr = 18446744073709545463LLU; // 99999998d1'''''''''''''''
105510	105288	break;
105511	105289	}
105512		- case 18446744073709545455LLU: // 99999998dt'''''''''''''''
	105290	+ case 18446744073709545463LLU: // 99999998d1'''''''''''''''
105513	105291	{
105514	105292	{
105515	105293	uint64_t mainresult = heap.data[0].elem0;

		@@ -105519,7 +105297,7 @@
105519	105297	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105520	105298	}
105521	105299	// 1LLU
105522		- uint64_t return_to = 18446744073709545453LLU;
	105300	+ uint64_t return_to = 18446744073709545461LLU;
105523	105301	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105524	105302	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105525	105303	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105528,12 +105306,12 @@
105528	105306	state.addr = 891913148528723755LLU; // verifyheap
105529	105307	break;
105530	105308	}
105531		- case 18446744073709545453LLU: // 99999998dr'''''''''''''''
	105309	+ case 18446744073709545461LLU: // 99999998dz'''''''''''''''
105532	105310	{
105533		- state.addr = 18446744073709545454LLU; // 99999998ds'''''''''''''''
	105311	+ state.addr = 18446744073709545462LLU; // 99999998d0'''''''''''''''
105534	105312	break;
105535	105313	}
105536		- case 18446744073709545454LLU: // 99999998ds'''''''''''''''
	105314	+ case 18446744073709545462LLU: // 99999998d0'''''''''''''''
105537	105315	{
105538	105316	fprintf(stdout, "%s", "\n if(heap.availilable_size_for_dynamic_objects != ");
105539	105317	fprintf(stdout, "%llu", (unsigned long long)/heapsize__/*LOCAL_ACCESS(heap.data, 13LLU, 3LLU));

		@@ -105564,7 +105342,7 @@
105564	105342	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105565	105343	}
105566	105344	// 2LLU
105567		- uint64_t return_to = 18446744073709545451LLU;
	105345	+ uint64_t return_to = 18446744073709545459LLU;
105568	105346	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105569	105347	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105570	105348	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105573,12 +105351,12 @@
105573	105351	state.addr = 587881350213860864LLU; // emitinit2_
105574	105352	break;
105575	105353	}
105576		- case 18446744073709545451LLU: // 99999998dp'''''''''''''''
	105354	+ case 18446744073709545459LLU: // 99999998dx'''''''''''''''
105577	105355	{
105578		- state.addr = 18446744073709545452LLU; // 99999998dq'''''''''''''''
	105356	+ state.addr = 18446744073709545460LLU; // 99999998dy'''''''''''''''
105579	105357	break;
105580	105358	}
105581		- case 18446744073709545452LLU: // 99999998dq'''''''''''''''
	105359	+ case 18446744073709545460LLU: // 99999998dy'''''''''''''''
105582	105360	{
105583	105361	fprintf(stdout, "%s", "\n");
105584	105362	{

		@@ -105601,7 +105379,7 @@
105601	105379	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105602	105380	}
105603	105381	// 2LLU
105604		- uint64_t return_to = 18446744073709545448LLU;
	105382	+ uint64_t return_to = 18446744073709545456LLU;
105605	105383	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105606	105384	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105607	105385	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105610,12 +105388,12 @@
105610	105388	state.addr = 819847183514601582LLU; // reportdefs
105611	105389	break;
105612	105390	}
105613		- case 18446744073709545448LLU: // 99999998dm'''''''''''''''
	105391	+ case 18446744073709545456LLU: // 99999998du'''''''''''''''
105614	105392	{
105615		- state.addr = 18446744073709545449LLU; // 99999998dn'''''''''''''''
	105393	+ state.addr = 18446744073709545457LLU; // 99999998dv'''''''''''''''
105616	105394	break;
105617	105395	}
105618		- case 18446744073709545449LLU: // 99999998dn'''''''''''''''
	105396	+ case 18446744073709545457LLU: // 99999998dv'''''''''''''''
105619	105397	{
105620	105398	list_size(heap.data, /fndefs____/LOCAL_ACCESS(heap.data, 15LLU, 8LLU), &/nr________/LOCAL_ACCESS(heap.data, 15LLU, 13LLU));
105621	105399	{

		@@ -105626,7 +105404,7 @@
105626	105404	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105627	105405	}
105628	105406	// 1LLU
105629		- uint64_t return_to = 18446744073709545446LLU;
	105407	+ uint64_t return_to = 18446744073709545454LLU;
105630	105408	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105631	105409	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105632	105410	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105635,12 +105413,12 @@
105635	105413	state.addr = 819847183517274112LLU; // reportnr__
105636	105414	break;
105637	105415	}
105638		- case 18446744073709545446LLU: // 99999998dk'''''''''''''''
	105416	+ case 18446744073709545454LLU: // 99999998ds'''''''''''''''
105639	105417	{
105640		- state.addr = 18446744073709545447LLU; // 99999998dl'''''''''''''''
	105418	+ state.addr = 18446744073709545455LLU; // 99999998dt'''''''''''''''
105641	105419	break;
105642	105420	}
105643		- case 18446744073709545447LLU: // 99999998dl'''''''''''''''
	105421	+ case 18446744073709545455LLU: // 99999998dt'''''''''''''''
105644	105422	{
105645	105423	fprintf(stderr, "%s", " procedure-/function-definitions\n");
105646	105424	{

		@@ -105655,7 +105433,7 @@
105655	105433	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105656	105434	}
105657	105435	// 2LLU
105658		- uint64_t return_to = 18446744073709545444LLU;
	105436	+ uint64_t return_to = 18446744073709545452LLU;
105659	105437	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105660	105438	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105661	105439	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105664,12 +105442,12 @@
105664	105442	state.addr = 819847183518878446LLU; // reporttyps
105665	105443	break;
105666	105444	}
105667		- case 18446744073709545444LLU: // 99999998di'''''''''''''''
	105445	+ case 18446744073709545452LLU: // 99999998dq'''''''''''''''
105668	105446	{
105669		- state.addr = 18446744073709545445LLU; // 99999998dj'''''''''''''''
	105447	+ state.addr = 18446744073709545453LLU; // 99999998dr'''''''''''''''
105670	105448	break;
105671	105449	}
105672		- case 18446744073709545445LLU: // 99999998dj'''''''''''''''
	105450	+ case 18446744073709545453LLU: // 99999998dr'''''''''''''''
105673	105451	{
105674	105452	list_size(heap.data, /typedefs__/LOCAL_ACCESS(heap.data, 15LLU, 9LLU), &/nr________/LOCAL_ACCESS(heap.data, 15LLU, 13LLU));
105675	105453	{

		@@ -105680,7 +105458,7 @@
105680	105458	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105681	105459	}
105682	105460	// 1LLU
105683		- uint64_t return_to = 18446744073709545442LLU;
	105461	+ uint64_t return_to = 18446744073709545450LLU;
105684	105462	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105685	105463	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105686	105464	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105689,12 +105467,12 @@
105689	105467	state.addr = 819847183517274112LLU; // reportnr__
105690	105468	break;
105691	105469	}
105692		- case 18446744073709545442LLU: // 99999998dg'''''''''''''''
	105470	+ case 18446744073709545450LLU: // 99999998do'''''''''''''''
105693	105471	{
105694		- state.addr = 18446744073709545443LLU; // 99999998dh'''''''''''''''
	105472	+ state.addr = 18446744073709545451LLU; // 99999998dp'''''''''''''''
105695	105473	break;
105696	105474	}
105697		- case 18446744073709545443LLU: // 99999998dh'''''''''''''''
	105475	+ case 18446744073709545451LLU: // 99999998dp'''''''''''''''
105698	105476	{
105699	105477	fprintf(stderr, "%s", " type-definitions\n");
105700	105478	// variable u64 def_id____ goes out of scope

		@@ -105703,10 +105481,10 @@
105703	105481	// variable u64 nr________ goes out of scope
105704	105482	// emitted destructur for type u64
105705	105483	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 14
105706		- state.addr = 18446744073709545450LLU; // 99999998do'''''''''''''''
	105484	+ state.addr = 18446744073709545458LLU; // 99999998dw'''''''''''''''
105707	105485	break;
105708	105486	}
105709		- case 18446744073709545450LLU: // 99999998do'''''''''''''''
	105487	+ case 18446744073709545458LLU: // 99999998dw'''''''''''''''
105710	105488	{
105711	105489	fprintf(stderr, "%s", "done\n");
105712	105490	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 13LLU, 0LLU)) = 0LLU;

		@@ -105727,14 +105505,14 @@
105727	105505	uint64_t arg = 0;
105728	105506	LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
105729	105507	}
105730		- state.addr = 18446744073709545440LLU; // 99999998de'''''''''''''''
	105508	+ state.addr = 18446744073709545448LLU; // 99999998dm'''''''''''''''
105731	105509	break;
105732	105510	}
105733		- case 18446744073709545440LLU: // 99999998de'''''''''''''''
	105511	+ case 18446744073709545448LLU: // 99999998dm'''''''''''''''
105734	105512	{
105735	105513	if(!LOCAL_ACCESS(heap.data, 11LLU, 9LLU)/list*/)
105736	105514	{
105737		- state.addr = 18446744073709545441LLU; // 99999998df'''''''''''''''
	105515	+ state.addr = 18446744073709545449LLU; // 99999998dn'''''''''''''''
105738	105516	break;
105739	105517	}
105740	105518	LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 11LLU, 9LLU)/list/, 6);

		@@ -105746,7 +105524,7 @@
105746	105524	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105747	105525	}
105748	105526	// 1LLU
105749		- uint64_t return_to = 18446744073709545439LLU;
	105527	+ uint64_t return_to = 18446744073709545447LLU;
105750	105528	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105751	105529	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105752	105530	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105755,12 +105533,12 @@
105755	105533	state.addr = 861504777589360324LLU; // typedef_$D
105756	105534	break;
105757	105535	}
105758		- case 18446744073709545439LLU: // 99999998dd'''''''''''''''
	105536	+ case 18446744073709545447LLU: // 99999998dl'''''''''''''''
105759	105537	{
105760		- state.addr = 18446744073709545440LLU; // 99999998de'''''''''''''''
	105538	+ state.addr = 18446744073709545448LLU; // 99999998dm'''''''''''''''
105761	105539	break;
105762	105540	}
105763		- case 18446744073709545441LLU: // 99999998df'''''''''''''''
	105541	+ case 18446744073709545449LLU: // 99999998dn'''''''''''''''
105764	105542	{
105765	105543	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
105766	105544	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedefs__ at 10

		@@ -105771,14 +105549,14 @@
105771	105549	uint64_t arg = 0;
105772	105550	LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
105773	105551	}
105774		- state.addr = 18446744073709545437LLU; // 99999998db'''''''''''''''
	105552	+ state.addr = 18446744073709545445LLU; // 99999998dj'''''''''''''''
105775	105553	break;
105776	105554	}
105777		- case 18446744073709545437LLU: // 99999998db'''''''''''''''
	105555	+ case 18446744073709545445LLU: // 99999998dj'''''''''''''''
105778	105556	{
105779	105557	if(!LOCAL_ACCESS(heap.data, 10LLU, 8LLU)/list*/)
105780	105558	{
105781		- state.addr = 18446744073709545438LLU; // 99999998dc'''''''''''''''
	105559	+ state.addr = 18446744073709545446LLU; // 99999998dk'''''''''''''''
105782	105560	break;
105783	105561	}
105784	105562	LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 10LLU, 8LLU)/list/, 9);

		@@ -105790,7 +105568,7 @@
105790	105568	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105791	105569	}
105792	105570	// 1LLU
105793		- uint64_t return_to = 18446744073709545436LLU;
	105571	+ uint64_t return_to = 18446744073709545444LLU;
105794	105572	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105795	105573	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105796	105574	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105799,12 +105577,12 @@
105799	105577	state.addr = 567601196335105732LLU; // defidfn_$D
105800	105578	break;
105801	105579	}
105802		- case 18446744073709545436LLU: // 99999998da'''''''''''''''
	105580	+ case 18446744073709545444LLU: // 99999998di'''''''''''''''
105803	105581	{
105804		- state.addr = 18446744073709545437LLU; // 99999998db'''''''''''''''
	105582	+ state.addr = 18446744073709545445LLU; // 99999998dj'''''''''''''''
105805	105583	break;
105806	105584	}
105807		- case 18446744073709545438LLU: // 99999998dc'''''''''''''''
	105585	+ case 18446744073709545446LLU: // 99999998dk'''''''''''''''
105808	105586	{
105809	105587	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
105810	105588	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fndefs____ at 9

		@@ -105815,14 +105593,14 @@
105815	105593	uint64_t arg = 0;
105816	105594	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
105817	105595	}
105818		- state.addr = 18446744073709545434LLU; // 99999998dZ'''''''''''''''
	105596	+ state.addr = 18446744073709545442LLU; // 99999998dg'''''''''''''''
105819	105597	break;
105820	105598	}
105821		- case 18446744073709545434LLU: // 99999998dZ'''''''''''''''
	105599	+ case 18446744073709545442LLU: // 99999998dg'''''''''''''''
105822	105600	{
105823	105601	if(!LOCAL_ACCESS(heap.data, 9LLU, 7LLU)/list*/)
105824	105602	{
105825		- state.addr = 18446744073709545435LLU; // 99999998d$'''''''''''''''
	105603	+ state.addr = 18446744073709545443LLU; // 99999998dh'''''''''''''''
105826	105604	break;
105827	105605	}
105828	105606	LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 7LLU)/list/, 2);

		@@ -105834,7 +105612,7 @@
105834	105612	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
105835	105613	}
105836	105614	// 1LLU
105837		- uint64_t return_to = 18446744073709545433LLU;
	105615	+ uint64_t return_to = 18446744073709545441LLU;
105838	105616	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
105839	105617	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
105840	105618	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -105843,12 +105621,12 @@
105843	105621	state.addr = 567659141321983684LLU; // destr___$D
105844	105622	break;
105845	105623	}
105846		- case 18446744073709545433LLU: // 99999998dY'''''''''''''''
	105624	+ case 18446744073709545441LLU: // 99999998df'''''''''''''''
105847	105625	{
105848		- state.addr = 18446744073709545434LLU; // 99999998dZ'''''''''''''''
	105626	+ state.addr = 18446744073709545442LLU; // 99999998dg'''''''''''''''
105849	105627	break;
105850	105628	}
105851		- case 18446744073709545435LLU: // 99999998d$'''''''''''''''
	105629	+ case 18446744073709545443LLU: // 99999998dh'''''''''''''''
105852	105630	{
105853	105631	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
105854	105632	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference destrs____ at 8

Show on old repository browser