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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	998 (tree)
Time	2020-04-30 07:08:56
Author	jakobthomsen

Log Message

use returning list

Change Summary

Incremental Difference

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

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

		@@ -5699,40 +5699,44 @@
5699	5699	case 782700512577972928LLU: // pardefscp_
5700	5700	{
5701	5701	{
5702		- uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
	5702	+ uint64_t arg = 0;
5703	5703	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
5704	5704	}
5705	5705	{
5706		- uint64_t arg = 0;
	5706	+ uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
5707	5707	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5708	5708	}
	5709	+ {
	5710	+ uint64_t arg = 0;
	5711	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5712	+ }
5709	5713	state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''
5710	5714	break;
5711	5715	}
5712	5716	case 18446744073709551418LLU: // 9999999964'''''''''''''''
5713	5717	{
5714		- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
	5718	+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5715	5719	{
	5720	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5716	5721	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5717		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
5718	5722	{
5719	5723	state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
5720	5724	break;
5721	5725	}
5722	5726	}
5723		- /direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
5724		- LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
	5727	+ /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
	5728	+ LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5725	5729	{
5726	5730	uint64_t arg = 0;
5727		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5731	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
5728	5732	}
5729	5733	// ACCUMULATE ARGUMENTS - BEGIN
5730	5734	{
5731		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	5735	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5732	5736	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5733	5737	}
5734	5738	{
5735		- uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
	5739	+ uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
5736	5740	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5737	5741	}
5738	5742	// ACCUMULATE ARGUMENTS - END

		@@ -5747,7 +5751,7 @@
5747	5751	}
5748	5752	case 18446744073709551413LLU: // 999999996z'''''''''''''''
5749	5753	{
5750		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 11) ? 18446744073709551416LLU : 18446744073709551415LLU;
	5754	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551416LLU : 18446744073709551415LLU;
5751	5755	break;
5752	5756	}
5753	5757	case 18446744073709551416LLU: // 9999999962'''''''''''''''

		@@ -5759,7 +5763,7 @@
5759	5763	// emitted destructur for type pardef____
5760	5764	// ACCUMULATE ARGUMENTS - BEGIN
5761	5765	{
5762		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	5766	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5763	5767	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5764	5768	}
5765	5769	// ACCUMULATE ARGUMENTS - END

		@@ -5785,7 +5789,7 @@
5785	5789	}
5786	5790	case 18446744073709551414LLU: // 9999999960'''''''''''''''
5787	5791	{
5788		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5792	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
5789	5793	// parameter-reference pardef____ src_______ goes out of scope
5790	5794	// parameter-reference list<pardef____> srcs______ goes out of scope
5791	5795	state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''

		@@ -5793,10 +5797,13 @@
5793	5797	}
5794	5798	case 18446744073709551417LLU: // 9999999963'''''''''''''''
5795	5799	{
	5800	+ swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	5801	+ // variable list<pardef____> dsts______ goes out of scope
	5802	+ // (uninitialized -> no destructor-call)
	5803	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 3
5796	5804	// parameter-reference list<pardef____> srcs______ goes out of scope
5797	5805	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srcs______ at 2
5798		- // parameter-reference list<pardef____> dsts______ goes out of scope
5799		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 1
	5806	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
5800	5807	{
5801	5808	uint64_t baseinfo = heap.data[0].elem1;
5802	5809	struct pair pair = unpair(&heap, &baseinfo);

		@@ -5808,50 +5815,54 @@
5808	5815	case 587581813005601646LLU: // elems2pars
5809	5816	{
5810	5817	{
5811		- uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
	5818	+ uint64_t arg = 0;
5812	5819	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5813	5820	}
5814	5821	{
5815		- uint64_t arg = 0;
	5822	+ uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
5816	5823	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
5817	5824	}
	5825	+ {
	5826	+ uint64_t arg = 0;
	5827	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5828	+ }
5818	5829	state.addr = 18446744073709551411LLU; // 999999996x'''''''''''''''
5819	5830	break;
5820	5831	}
5821	5832	case 18446744073709551411LLU: // 999999996x'''''''''''''''
5822	5833	{
5823		- if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
	5834	+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
5824	5835	{
	5836	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
5825	5837	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5826		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5827	5838	{
5828	5839	state.addr = 18446744073709551410LLU; // 999999996w'''''''''''''''
5829	5840	break;
5830	5841	}
5831	5842	}
5832		- /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5833		- LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
	5843	+ /direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
	5844	+ LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
5834	5845	{
5835	5846	uint64_t arg = 0;
5836		- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5847	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
5837	5848	}
5838		- *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = 1;
	5849	+ *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = 1;
5839	5850	{
5840	5851	uint64_t arg = 0;
5841		- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	5852	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
5842	5853	}
5843		- LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /reference_/LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
	5854	+ LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /reference_/LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5844	5855	{
5845	5856	uint64_t arg = 0;
5846		- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	5857	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
5847	5858	}
5848	5859	// ACCUMULATE ARGUMENTS - BEGIN
5849	5860	{
5850		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	5861	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
5851	5862	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5852	5863	}
5853	5864	{
5854		- uint64_t arg = /src_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 1LLU);
	5865	+ uint64_t arg = /src_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 1LLU);
5855	5866	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5856	5867	}
5857	5868	// ACCUMULATE ARGUMENTS - END

		@@ -5868,11 +5879,11 @@
5868	5879	{
5869	5880	{
5870	5881	uint64_t arg = 0;
5871		- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	5882	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
5872	5883	}
5873	5884	// ACCUMULATE ARGUMENTS - BEGIN
5874	5885	{
5875		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
	5886	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
5876	5887	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5877	5888	}
5878	5889	// ACCUMULATE ARGUMENTS - END

		@@ -5889,27 +5900,27 @@
5889	5900	{
5890	5901	{
5891	5902	uint64_t arg = 0;
5892		- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	5903	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
5893	5904	}
5894	5905	// ACCUMULATE ARGUMENTS - BEGIN
5895	5906	{
5896		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	5907	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5897	5908	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5898	5909	}
5899	5910	{
5900		- uint64_t arg = /type______/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
	5911	+ uint64_t arg = /type______/*LOCAL_ACCESS(heap.data, 11LLU, 8LLU);
5901	5912	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5902	5913	}
5903	5914	{
5904		- uint64_t arg = /mutable___/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
	5915	+ uint64_t arg = /mutable___/*LOCAL_ACCESS(heap.data, 11LLU, 6LLU);
5905	5916	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5906	5917	}
5907	5918	{
5908		- uint64_t arg = /continuity/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
	5919	+ uint64_t arg = /continuity/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
5909	5920	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5910	5921	}
5911	5922	{
5912		- uint64_t arg = /reference_/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
	5923	+ uint64_t arg = /reference_/*LOCAL_ACCESS(heap.data, 11LLU, 7LLU);
5913	5924	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5914	5925	}
5915	5926	// ACCUMULATE ARGUMENTS - END

		@@ -5924,7 +5935,7 @@
5924	5935	}
5925	5936	case 18446744073709551404LLU: // 999999996q'''''''''''''''
5926	5937	{
5927		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)), 11) ? 18446744073709551407LLU : 18446744073709551406LLU;
	5938	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551407LLU : 18446744073709551406LLU;
5928	5939	break;
5929	5940	}
5930	5941	case 18446744073709551407LLU: // 999999996t'''''''''''''''

		@@ -5932,7 +5943,7 @@
5932	5943	fprintf(stderr, "%s", "pushing par ");
5933	5944	// ACCUMULATE ARGUMENTS - BEGIN
5934	5945	{
5935		- uint64_t arg = /newpar____/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU), 0LLU);
	5946	+ uint64_t arg = /newpar____/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU), 0LLU);
5936	5947	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5937	5948	}
5938	5949	// ACCUMULATE ARGUMENTS - END

		@@ -5955,7 +5966,7 @@
5955	5966	// emitted destructur for type pardef____
5956	5967	// ACCUMULATE ARGUMENTS - BEGIN
5957	5968	{
5958		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	5969	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5959	5970	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5960	5971	}
5961	5972	// ACCUMULATE ARGUMENTS - END

		@@ -5981,19 +5992,19 @@
5981	5992	}
5982	5993	case 18446744073709551405LLU: // 999999996r'''''''''''''''
5983	5994	{
5984		- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
	5995	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
5985	5996	// variable continuity continuity goes out of scope
5986	5997	// (uninitialized -> no destructor-call)
5987		- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference continuity at 9
	5998	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference continuity at 10
5988	5999	// variable type______ type______ goes out of scope
5989	6000	// (uninitialized -> no destructor-call)
5990		- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 8
	6001	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 9
5991	6002	// variable u64 reference_ goes out of scope
5992	6003	// (uninitialized -> no destructor-call)
5993		- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 7
	6004	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 8
5994	6005	// variable u64 mutable___ goes out of scope
5995	6006	// (uninitialized -> no destructor-call)
5996		- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 6
	6007	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 7
5997	6008	// parameter-reference elemdef___ src_______ goes out of scope
5998	6009	// parameter-reference list<elemdef___> srcs______ goes out of scope
5999	6010	state.addr = 18446744073709551411LLU; // 999999996x'''''''''''''''

		@@ -6001,12 +6012,15 @@
6001	6012	}
6002	6013	case 18446744073709551410LLU: // 999999996w'''''''''''''''
6003	6014	{
	6015	+ swap(&LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
	6016	+ // variable list<pardef____> dsts______ goes out of scope
	6017	+ // (uninitialized -> no destructor-call)
	6018	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 4
6004	6019	// parameter u64 reference_ goes out of scope
6005	6020	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 3
6006	6021	// parameter-reference list<elemdef___> srcs______ goes out of scope
6007	6022	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srcs______ at 2
6008		- // parameter-reference list<pardef____> dsts______ goes out of scope
6009		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 1
	6023	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
6010	6024	{
6011	6025	uint64_t baseinfo = heap.data[0].elem1;
6012	6026	struct pair pair = unpair(&heap, &baseinfo);

		@@ -6136,40 +6150,44 @@
6136	6150	case 587581796494272427LLU: // elemdefscp
6137	6151	{
6138	6152	{
6139		- uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
	6153	+ uint64_t arg = 0;
6140	6154	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
6141	6155	}
6142	6156	{
6143		- uint64_t arg = 0;
	6157	+ uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
6144	6158	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
6145	6159	}
	6160	+ {
	6161	+ uint64_t arg = 0;
	6162	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	6163	+ }
6146	6164	state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
6147	6165	break;
6148	6166	}
6149	6167	case 18446744073709551397LLU: // 999999996j'''''''''''''''
6150	6168	{
6151		- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
	6169	+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6152	6170	{
	6171	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
6153	6172	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6154		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
6155	6173	{
6156	6174	state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
6157	6175	break;
6158	6176	}
6159	6177	}
6160		- /direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
6161		- LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
	6178	+ /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
	6179	+ LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
6162	6180	{
6163	6181	uint64_t arg = 0;
6164		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	6182	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
6165	6183	}
6166	6184	// ACCUMULATE ARGUMENTS - BEGIN
6167	6185	{
6168		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	6186	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6169	6187	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6170	6188	}
6171	6189	{
6172		- uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
	6190	+ uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
6173	6191	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6174	6192	}
6175	6193	// ACCUMULATE ARGUMENTS - END

		@@ -6184,7 +6202,7 @@
6184	6202	}
6185	6203	case 18446744073709551392LLU: // 999999996e'''''''''''''''
6186	6204	{
6187		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 7) ? 18446744073709551395LLU : 18446744073709551394LLU;
	6205	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551395LLU : 18446744073709551394LLU;
6188	6206	break;
6189	6207	}
6190	6208	case 18446744073709551395LLU: // 999999996h'''''''''''''''

		@@ -6192,7 +6210,7 @@
6192	6210	fprintf(stderr, "%s", "pushing par ");
6193	6211	// ACCUMULATE ARGUMENTS - BEGIN
6194	6212	{
6195		- uint64_t arg = /dst_______/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU), 1LLU);
	6213	+ uint64_t arg = /dst_______/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU), 1LLU);
6196	6214	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6197	6215	}
6198	6216	// ACCUMULATE ARGUMENTS - END

		@@ -6215,7 +6233,7 @@
6215	6233	// emitted destructur for type elemdef___
6216	6234	// ACCUMULATE ARGUMENTS - BEGIN
6217	6235	{
6218		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	6236	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6219	6237	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6220	6238	}
6221	6239	// ACCUMULATE ARGUMENTS - END

		@@ -6241,7 +6259,7 @@
6241	6259	}
6242	6260	case 18446744073709551393LLU: // 999999996f'''''''''''''''
6243	6261	{
6244		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	6262	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
6245	6263	// parameter-reference elemdef___ src_______ goes out of scope
6246	6264	// parameter-reference list<elemdef___> srcs______ goes out of scope
6247	6265	state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''

		@@ -6249,10 +6267,13 @@
6249	6267	}
6250	6268	case 18446744073709551396LLU: // 999999996i'''''''''''''''
6251	6269	{
	6270	+ swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	6271	+ // variable list<elemdef___> dsts______ goes out of scope
	6272	+ // (uninitialized -> no destructor-call)
	6273	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 3
6252	6274	// parameter-reference list<elemdef___> srcs______ goes out of scope
6253	6275	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srcs______ at 2
6254		- // parameter-reference list<elemdef___> dsts______ goes out of scope
6255		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 1
	6276	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
6256	6277	{
6257	6278	uint64_t baseinfo = heap.data[0].elem1;
6258	6279	struct pair pair = unpair(&heap, &baseinfo);

		@@ -9569,40 +9590,44 @@
9569	9590	case 552446646814171136LLU: // copyvars__
9570	9591	{
9571	9592	{
9572		- uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
	9593	+ uint64_t arg = 0;
9573	9594	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
9574	9595	}
9575	9596	{
9576		- uint64_t arg = 0;
	9597	+ uint64_t arg = /srcs______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
9577	9598	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
9578	9599	}
	9600	+ {
	9601	+ uint64_t arg = 0;
	9602	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	9603	+ }
9579	9604	state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
9580	9605	break;
9581	9606	}
9582	9607	case 18446744073709551207LLU: // 999999993l'''''''''''''''
9583	9608	{
9584		- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
	9609	+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
9585	9610	{
	9611	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
9586	9612	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
9587		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
9588	9613	{
9589	9614	state.addr = 18446744073709551206LLU; // 999999993k'''''''''''''''
9590	9615	break;
9591	9616	}
9592	9617	}
9593		- /direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
9594		- LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
	9618	+ /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
	9619	+ LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
9595	9620	{
9596	9621	uint64_t arg = 0;
9597		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	9622	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
9598	9623	}
9599	9624	// ACCUMULATE ARGUMENTS - BEGIN
9600	9625	{
9601		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	9626	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
9602	9627	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9603	9628	}
9604	9629	{
9605		- uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
	9630	+ uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
9606	9631	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9607	9632	}
9608	9633	// ACCUMULATE ARGUMENTS - END

		@@ -9617,7 +9642,7 @@
9617	9642	}
9618	9643	case 18446744073709551202LLU: // 999999993g'''''''''''''''
9619	9644	{
9620		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 4) ? 18446744073709551205LLU : 18446744073709551204LLU;
	9645	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551205LLU : 18446744073709551204LLU;
9621	9646	break;
9622	9647	}
9623	9648	case 18446744073709551205LLU: // 999999993j'''''''''''''''

		@@ -9629,7 +9654,7 @@
9629	9654	// emitted destructur for type variant___
9630	9655	// ACCUMULATE ARGUMENTS - BEGIN
9631	9656	{
9632		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	9657	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
9633	9658	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9634	9659	}
9635	9660	// ACCUMULATE ARGUMENTS - END

		@@ -9655,7 +9680,7 @@
9655	9680	}
9656	9681	case 18446744073709551203LLU: // 999999993h'''''''''''''''
9657	9682	{
9658		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	9683	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
9659	9684	// parameter-reference variant___ src_______ goes out of scope
9660	9685	// parameter-reference list<variant___> srcs______ goes out of scope
9661	9686	state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''

		@@ -9663,10 +9688,13 @@
9663	9688	}
9664	9689	case 18446744073709551206LLU: // 999999993k'''''''''''''''
9665	9690	{
	9691	+ swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
	9692	+ // variable list<variant___> dsts______ goes out of scope
	9693	+ // (uninitialized -> no destructor-call)
	9694	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 3
9666	9695	// parameter-reference list<variant___> srcs______ goes out of scope
9667	9696	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srcs______ at 2
9668		- // parameter-reference list<variant___> dsts______ goes out of scope
9669		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dsts______ at 1
	9697	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
9670	9698	{
9671	9699	uint64_t baseinfo = heap.data[0].elem1;
9672	9700	struct pair pair = unpair(&heap, &baseinfo);

		@@ -44478,17 +44506,34 @@
44478	44506	uint64_t arg = 0;
44479	44507	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
44480	44508	}
	44509	+ {
	44510	+ uint64_t arg = 0;
	44511	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	44512	+ }
44481	44513	// ACCUMULATE ARGUMENTS - BEGIN
44482	44514	{
44483		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	44515	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
44484	44516	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44485	44517	}
	44518	+ {
	44519	+ uint64_t arg = heap.data[0].elem0;
	44520	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	44521	+ }
	44522	+ {
	44523	+ uint64_t arg = 0;
	44524	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	44525	+ }
	44526	+ // ACCUMULATE ARGUMENTS - BEGIN
44486	44527	{
44487		- uint64_t arg = /type______/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU);
	44528	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	44529	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	44530	+ }
	44531	+ {
	44532	+ uint64_t arg = /type______/*LOCAL_ACCESS(heap.data, 8LLU, 1LLU);
44488	44533	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44489	44534	}
44490	44535	// ACCUMULATE ARGUMENTS - END
44491		- uint64_t return_to = 18446744073709549653LLU;
	44536	+ uint64_t return_to = 18446744073709549649LLU;
44492	44537	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
44493	44538	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44494	44539	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44497,18 +44542,21 @@
44497	44542	state.addr = 367395560426147840LLU; // TYPECOPY__
44498	44543	break;
44499	44544	}
44500		- case 18446744073709549653LLU: // 99999999fU'''''''''''''''
	44545	+ case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
44501	44546	{
44502	44547	{
44503		- uint64_t arg = 0;
44504		- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	44548	+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;
	44549	+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;
	44550	+
	44551	+ {
	44552	+ uint64_t arg = exchange;
	44553	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	44554	+ }
44505	44555	}
44506		- LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /idx_______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
44507	44556	{
44508		- uint64_t arg = 0;
	44557	+ uint64_t arg = heap.data[0].elem0;
44509	44558	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
44510	44559	}
44511		- LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /reference_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
44512	44560	{
44513	44561	uint64_t arg = 0;
44514	44562	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);

		@@ -44519,19 +44567,70 @@
44519	44567	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44520	44568	}
44521	44569	{
44522		- uint64_t arg = /TYPE______/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
	44570	+ uint64_t arg = /idx_______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 2LLU));
44523	44571	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44524	44572	}
	44573	+ // ACCUMULATE ARGUMENTS - END
	44574	+ uint64_t return_to = 18446744073709549648LLU;
	44575	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	44576	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	44577	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	44578	+ heap.data[0].elem1 = heap.data[0].elem0;
	44579	+ heap.data[0].elem0 = restore;
	44580	+ state.addr = 552446646280519680LLU; // copyu64___
	44581	+ break;
	44582	+ }
	44583	+ case 18446744073709549648LLU: // 99999999fP'''''''''''''''
	44584	+ {
	44585	+ {
	44586	+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;
	44587	+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;
	44588	+
44525	44589	{
44526		- uint64_t arg = /idx_______/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
	44590	+ uint64_t arg = exchange;
44527	44591	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44528	44592	}
	44593	+ }
	44594	+ {
	44595	+ uint64_t arg = heap.data[0].elem0;
	44596	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	44597	+ }
	44598	+ {
	44599	+ uint64_t arg = 0;
	44600	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	44601	+ }
	44602	+ // ACCUMULATE ARGUMENTS - BEGIN
44529	44603	{
44530		- uint64_t arg = /reference_/*LOCAL_ACCESS(heap.data, 8LLU, 6LLU);
	44604	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	44605	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	44606	+ }
	44607	+ {
	44608	+ uint64_t arg = /reference_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 3LLU));
	44609	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	44610	+ }
	44611	+ // ACCUMULATE ARGUMENTS - END
	44612	+ uint64_t return_to = 18446744073709549647LLU;
	44613	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	44614	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	44615	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	44616	+ heap.data[0].elem1 = heap.data[0].elem0;
	44617	+ heap.data[0].elem0 = restore;
	44618	+ state.addr = 552446646280519680LLU; // copyu64___
	44619	+ break;
	44620	+ }
	44621	+ case 18446744073709549647LLU: // 99999999fO'''''''''''''''
	44622	+ {
	44623	+ {
	44624	+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;
	44625	+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;
	44626	+
	44627	+ {
	44628	+ uint64_t arg = exchange;
44531	44629	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44532	44630	}
	44631	+ }
44533	44632	// ACCUMULATE ARGUMENTS - END
44534		- uint64_t return_to = 18446744073709549649LLU;
	44633	+ uint64_t return_to = 18446744073709549650LLU;
44535	44634	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
44536	44635	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44537	44636	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44540,12 +44639,12 @@
44540	44639	state.addr = 819859607768530944LLU; // resdest___
44541	44640	break;
44542	44641	}
44543		- case 18446744073709549649LLU: // 99999999fQ'''''''''''''''
	44642	+ case 18446744073709549650LLU: // 99999999fR'''''''''''''''
44544	44643	{
44545		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)), 8) ? 18446744073709549652LLU : 18446744073709549651LLU;
	44644	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 8) ? 18446744073709549653LLU : 18446744073709549652LLU;
44546	44645	break;
44547	44646	}
44548		- case 18446744073709549652LLU: // 99999999fT'''''''''''''''
	44647	+ case 18446744073709549653LLU: // 99999999fU'''''''''''''''
44549	44648	{
44550	44649	{
44551	44650	fprintf(stderr, "%s\n", "INTERNAL ERROR - out of dynamic heap in oneresult - recompile compiler with more dynamic heap");

		@@ -44554,11 +44653,11 @@
44554	44653	// emitted destructur for type resdest___
44555	44654	// ACCUMULATE ARGUMENTS - BEGIN
44556	44655	{
44557		- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	44656	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
44558	44657	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44559	44658	}
44560	44659	// ACCUMULATE ARGUMENTS - END
44561		- uint64_t return_to = 18446744073709549648LLU;
	44660	+ uint64_t return_to = 18446744073709549646LLU;
44562	44661	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44563	44662	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44564	44663	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44567,29 +44666,24 @@
44567	44666	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
44568	44667	break;
44569	44668	}
44570		- case 18446744073709549648LLU: // 99999999fP'''''''''''''''
	44669	+ case 18446744073709549646LLU: // 99999999fN'''''''''''''''
44571	44670	{
44572	44671	// parameter resdest___ tmp_______ goes out of scope
44573		- state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
	44672	+ state.addr = 18446744073709549651LLU; // 99999999fS'''''''''''''''
44574	44673	break;
44575	44674	}
44576		- case 18446744073709549651LLU: // 99999999fS'''''''''''''''
	44675	+ case 18446744073709549652LLU: // 99999999fT'''''''''''''''
44577	44676	{
44578		- state.addr = 18446744073709549650LLU; // 99999999fR'''''''''''''''
	44677	+ state.addr = 18446744073709549651LLU; // 99999999fS'''''''''''''''
44579	44678	break;
44580	44679	}
44581		- case 18446744073709549650LLU: // 99999999fR'''''''''''''''
	44680	+ case 18446744073709549651LLU: // 99999999fS'''''''''''''''
44582	44681	{
44583		- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
44584		- // variable u64 reference_ goes out of scope
	44682	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
	44683	+ swap(&LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
	44684	+ // variable list<resdest___> results___ goes out of scope
44585	44685	// (uninitialized -> no destructor-call)
44586		- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 7
44587		- // variable u64 idx_______ goes out of scope
44588		- // (uninitialized -> no destructor-call)
44589		- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 6
44590		- // variable type______ TYPE______ goes out of scope
44591		- // (uninitialized -> no destructor-call)
44592		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPE______ at 5
	44686	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 5
44593	44687	// parameter-reference u64 reference_ goes out of scope
44594	44688	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 4
44595	44689	// parameter-reference u64 idx_______ goes out of scope

		@@ -44596,8 +44690,7 @@
44596	44690	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 3
44597	44691	// parameter-reference type______ type______ goes out of scope
44598	44692	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2
44599		- // parameter-reference list<resdest___> results___ goes out of scope
44600		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference results___ at 1
	44693	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
44601	44694	{
44602	44695	uint64_t baseinfo = heap.data[0].elem1;
44603	44696	struct pair pair = unpair(&heap, &baseinfo);

		@@ -44619,11 +44712,11 @@
44619	44712	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
44620	44713	}
44621	44714	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /sz________/LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
44622		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549647LLU : 18446744073709549646LLU;
	44715	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709549645LLU : 18446744073709549644LLU;
44623	44716	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
44624	44717	break;
44625	44718	}
44626		- case 18446744073709549647LLU: // 99999999fO'''''''''''''''
	44719	+ case 18446744073709549645LLU: // 99999999fM'''''''''''''''
44627	44720	{
44628	44721	++/sz________/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
44629	44722	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -44632,7 +44725,7 @@
44632	44725	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44633	44726	}
44634	44727	// ACCUMULATE ARGUMENTS - END
44635		- uint64_t return_to = 18446744073709549645LLU;
	44728	+ uint64_t return_to = 18446744073709549643LLU;
44636	44729	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44637	44730	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44638	44731	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44641,7 +44734,7 @@
44641	44734	state.addr = 819847183515949359LLU; // reportinit
44642	44735	break;
44643	44736	}
44644		- case 18446744073709549645LLU: // 99999999fM'''''''''''''''
	44737	+ case 18446744073709549643LLU: // 99999999fK'''''''''''''''
44645	44738	{
44646	44739	fprintf(stderr, "%s", "built-in function returns (u64) but caller expects ");
44647	44740	fprintf(stderr, "%llu", (unsigned long long)/sz________/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));

		@@ -44650,10 +44743,10 @@
44650	44743	fprintf(stderr, "%s\n", "");
44651	44744	exit(-1);
44652	44745	}
44653		- state.addr = 18446744073709549646LLU; // 99999999fN'''''''''''''''
	44746	+ state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
44654	44747	break;
44655	44748	}
44656		- case 18446744073709549646LLU: // 99999999fN'''''''''''''''
	44749	+ case 18446744073709549644LLU: // 99999999fL'''''''''''''''
44657	44750	{
44658	44751	{
44659	44752	uint64_t arg = /res_______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 3LLU));

		@@ -44663,10 +44756,10 @@
44663	44756	uint64_t arg = 0;
44664	44757	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
44665	44758	}
44666		- state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
	44759	+ state.addr = 18446744073709549642LLU; // 99999999fJ'''''''''''''''
44667	44760	break;
44668	44761	}
44669		- case 18446744073709549644LLU: // 99999999fL'''''''''''''''
	44762	+ case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
44670	44763	{
44671	44764	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
44672	44765	{

		@@ -44673,7 +44766,7 @@
44673	44766	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
44674	44767	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
44675	44768	{
44676		- state.addr = 18446744073709549643LLU; // 99999999fK'''''''''''''''
	44769	+ state.addr = 18446744073709549641LLU; // 99999999fI'''''''''''''''
44677	44770	break;
44678	44771	}
44679	44772	}

		@@ -44687,7 +44780,7 @@
44687	44780	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44688	44781	}
44689	44782	// ACCUMULATE ARGUMENTS - END
44690		- uint64_t return_to = 18446744073709549642LLU;
	44783	+ uint64_t return_to = 18446744073709549640LLU;
44691	44784	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44692	44785	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44693	44786	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44696,7 +44789,7 @@
44696	44789	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
44697	44790	break;
44698	44791	}
44699		- case 18446744073709549642LLU: // 99999999fJ'''''''''''''''
	44792	+ case 18446744073709549640LLU: // 99999999fH'''''''''''''''
44700	44793	{
44701	44794	// ACCUMULATE ARGUMENTS - BEGIN
44702	44795	{

		@@ -44708,7 +44801,7 @@
44708	44801	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44709	44802	}
44710	44803	// ACCUMULATE ARGUMENTS - END
44711		- uint64_t return_to = 18446744073709549641LLU;
	44804	+ uint64_t return_to = 18446744073709549639LLU;
44712	44805	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
44713	44806	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44714	44807	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44717,14 +44810,14 @@
44717	44810	state.addr = 325750391286068249LLU; // RESDEFCOPY
44718	44811	break;
44719	44812	}
44720		- case 18446744073709549641LLU: // 99999999fI'''''''''''''''
	44813	+ case 18446744073709549639LLU: // 99999999fG'''''''''''''''
44721	44814	{
44722	44815	// parameter-reference resdest___ tmp_______ goes out of scope
44723	44816	// parameter-reference list<resdest___> res_______ goes out of scope
44724		- state.addr = 18446744073709549644LLU; // 99999999fL'''''''''''''''
	44817	+ state.addr = 18446744073709549642LLU; // 99999999fJ'''''''''''''''
44725	44818	break;
44726	44819	}
44727		- case 18446744073709549643LLU: // 99999999fK'''''''''''''''
	44820	+ case 18446744073709549641LLU: // 99999999fI'''''''''''''''
44728	44821	{
44729	44822	// variable u64 sz________ goes out of scope
44730	44823	// emitted destructur for type u64

		@@ -44758,11 +44851,11 @@
44758	44851	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
44759	44852	}
44760	44853	LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /sz________/LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
44761		- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549640LLU : 18446744073709549639LLU;
	44854	+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709549638LLU : 18446744073709549637LLU;
44762	44855	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
44763	44856	break;
44764	44857	}
44765		- case 18446744073709549640LLU: // 99999999fH'''''''''''''''
	44858	+ case 18446744073709549638LLU: // 99999999fF'''''''''''''''
44766	44859	{
44767	44860	++/sz________/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
44768	44861	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -44771,7 +44864,7 @@
44771	44864	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44772	44865	}
44773	44866	// ACCUMULATE ARGUMENTS - END
44774		- uint64_t return_to = 18446744073709549638LLU;
	44867	+ uint64_t return_to = 18446744073709549636LLU;
44775	44868	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44776	44869	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44777	44870	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44780,7 +44873,7 @@
44780	44873	state.addr = 819847183515949359LLU; // reportinit
44781	44874	break;
44782	44875	}
44783		- case 18446744073709549638LLU: // 99999999fF'''''''''''''''
	44876	+ case 18446744073709549636LLU: // 99999999fD'''''''''''''''
44784	44877	{
44785	44878	fprintf(stderr, "%s", "found ");
44786	44879	fprintf(stderr, "%llu", (unsigned long long)/sz________/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));

		@@ -44789,10 +44882,10 @@
44789	44882	fprintf(stderr, "%s\n", "");
44790	44883	exit(-1);
44791	44884	}
44792		- state.addr = 18446744073709549639LLU; // 99999999fG'''''''''''''''
	44885	+ state.addr = 18446744073709549637LLU; // 99999999fE'''''''''''''''
44793	44886	break;
44794	44887	}
44795		- case 18446744073709549639LLU: // 99999999fG'''''''''''''''
	44888	+ case 18446744073709549637LLU: // 99999999fE'''''''''''''''
44796	44889	{
44797	44890	{
44798	44891	uint64_t arg = 0;

		@@ -44817,7 +44910,7 @@
44817	44910	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44818	44911	}
44819	44912	// ACCUMULATE ARGUMENTS - END
44820		- uint64_t return_to = 18446744073709549636LLU;
	44913	+ uint64_t return_to = 18446744073709549634LLU;
44821	44914	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44822	44915	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44823	44916	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44826,7 +44919,7 @@
44826	44919	state.addr = 861504796319285248LLU; // typeu64___
44827	44920	break;
44828	44921	}
44829		- case 18446744073709549636LLU: // 99999999fD'''''''''''''''
	44922	+ case 18446744073709549634LLU: // 99999999fB'''''''''''''''
44830	44923	{
44831	44924	{
44832	44925	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -44846,7 +44939,7 @@
44846	44939	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44847	44940	}
44848	44941	// ACCUMULATE ARGUMENTS - END
44849		- uint64_t return_to = 18446744073709549637LLU;
	44942	+ uint64_t return_to = 18446744073709549635LLU;
44850	44943	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
44851	44944	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44852	44945	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44855,7 +44948,7 @@
44855	44948	state.addr = 819859607768530944LLU; // resdest___
44856	44949	break;
44857	44950	}
44858		- case 18446744073709549637LLU: // 99999999fE'''''''''''''''
	44951	+ case 18446744073709549635LLU: // 99999999fC'''''''''''''''
44859	44952	{
44860	44953	{
44861	44954	uint64_t arg = /res_______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 2LLU));

		@@ -44865,10 +44958,10 @@
44865	44958	uint64_t arg = 0;
44866	44959	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
44867	44960	}
44868		- state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
	44961	+ state.addr = 18446744073709549633LLU; // 99999999fA'''''''''''''''
44869	44962	break;
44870	44963	}
44871		- case 18446744073709549635LLU: // 99999999fC'''''''''''''''
	44964	+ case 18446744073709549633LLU: // 99999999fA'''''''''''''''
44872	44965	{
44873	44966	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
44874	44967	{

		@@ -44875,7 +44968,7 @@
44875	44968	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
44876	44969	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
44877	44970	{
44878		- state.addr = 18446744073709549634LLU; // 99999999fB'''''''''''''''
	44971	+ state.addr = 18446744073709549632LLU; // 99999999f_'''''''''''''''
44879	44972	break;
44880	44973	}
44881	44974	}

		@@ -44889,7 +44982,7 @@
44889	44982	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44890	44983	}
44891	44984	// ACCUMULATE ARGUMENTS - END
44892		- uint64_t return_to = 18446744073709549633LLU;
	44985	+ uint64_t return_to = 18446744073709549631LLU;
44893	44986	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
44894	44987	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44895	44988	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44898,7 +44991,7 @@
44898	44991	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
44899	44992	break;
44900	44993	}
44901		- case 18446744073709549633LLU: // 99999999fA'''''''''''''''
	44994	+ case 18446744073709549631LLU: // 99999999e9'''''''''''''''
44902	44995	{
44903	44996	// ACCUMULATE ARGUMENTS - BEGIN
44904	44997	{

		@@ -44910,7 +45003,7 @@
44910	45003	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44911	45004	}
44912	45005	// ACCUMULATE ARGUMENTS - END
44913		- uint64_t return_to = 18446744073709549632LLU;
	45006	+ uint64_t return_to = 18446744073709549630LLU;
44914	45007	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
44915	45008	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44916	45009	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44919,14 +45012,14 @@
44919	45012	state.addr = 325750391286068249LLU; // RESDEFCOPY
44920	45013	break;
44921	45014	}
44922		- case 18446744073709549632LLU: // 99999999f_'''''''''''''''
	45015	+ case 18446744073709549630LLU: // 99999999e8'''''''''''''''
44923	45016	{
44924	45017	// parameter-reference resdest___ tmp_______ goes out of scope
44925	45018	// parameter-reference list<resdest___> res_______ goes out of scope
44926		- state.addr = 18446744073709549635LLU; // 99999999fC'''''''''''''''
	45019	+ state.addr = 18446744073709549633LLU; // 99999999fA'''''''''''''''
44927	45020	break;
44928	45021	}
44929		- case 18446744073709549634LLU: // 99999999fB'''''''''''''''
	45022	+ case 18446744073709549632LLU: // 99999999f_'''''''''''''''
44930	45023	{
44931	45024	swap(&LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU))); // result
44932	45025	// variable resdest___ single____ goes out of scope

		@@ -44968,7 +45061,7 @@
44968	45061	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44969	45062	}
44970	45063	// ACCUMULATE ARGUMENTS - END
44971		- uint64_t return_to = 18446744073709549631LLU;
	45064	+ uint64_t return_to = 18446744073709549629LLU;
44972	45065	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
44973	45066	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44974	45067	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44977,7 +45070,7 @@
44977	45070	state.addr = 819857492327934432LLU; // res_single
44978	45071	break;
44979	45072	}
44980		- case 18446744073709549631LLU: // 99999999e9'''''''''''''''
	45073	+ case 18446744073709549629LLU: // 99999999e7'''''''''''''''
44981	45074	{
44982	45075	// ACCUMULATE ARGUMENTS - BEGIN
44983	45076	{

		@@ -44989,7 +45082,7 @@
44989	45082	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
44990	45083	}
44991	45084	// ACCUMULATE ARGUMENTS - END
44992		- uint64_t return_to = 18446744073709549630LLU;
	45085	+ uint64_t return_to = 18446744073709549628LLU;
44993	45086	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
44994	45087	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
44995	45088	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -44998,7 +45091,7 @@
44998	45091	state.addr = 517555565476695680LLU; // assertu64_
44999	45092	break;
45000	45093	}
45001		- case 18446744073709549630LLU: // 99999999e8'''''''''''''''
	45094	+ case 18446744073709549628LLU: // 99999999e6'''''''''''''''
45002	45095	{
45003	45096	// parameter-reference list<resdest___> res_______ goes out of scope
45004	45097	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res_______ at 4

		@@ -45032,11 +45125,11 @@
45032	45125	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
45033	45126	}
45034	45127	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45035		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549629LLU : 18446744073709549628LLU;
	45128	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549627LLU : 18446744073709549626LLU;
45036	45129	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
45037	45130	break;
45038	45131	}
45039		- case 18446744073709549629LLU: // 99999999e7'''''''''''''''
	45132	+ case 18446744073709549627LLU: // 99999999e5'''''''''''''''
45040	45133	{
45041	45134	{
45042	45135	uint64_t arg = 0;

		@@ -45061,7 +45154,7 @@
45061	45154	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45062	45155	}
45063	45156	// ACCUMULATE ARGUMENTS - END
45064		- uint64_t return_to = 18446744073709549625LLU;
	45157	+ uint64_t return_to = 18446744073709549623LLU;
45065	45158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45066	45159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45067	45160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45070,7 +45163,7 @@
45070	45163	state.addr = 861504796319285248LLU; // typeu64___
45071	45164	break;
45072	45165	}
45073		- case 18446744073709549625LLU: // 99999999e3'''''''''''''''
	45166	+ case 18446744073709549623LLU: // 99999999e1'''''''''''''''
45074	45167	{
45075	45168	{
45076	45169	uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 19*/;

		@@ -45090,7 +45183,7 @@
45090	45183	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45091	45184	}
45092	45185	// ACCUMULATE ARGUMENTS - END
45093		- uint64_t return_to = 18446744073709549626LLU;
	45186	+ uint64_t return_to = 18446744073709549624LLU;
45094	45187	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45095	45188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45096	45189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45099,7 +45192,7 @@
45099	45192	state.addr = 819859607768530944LLU; // resdest___
45100	45193	break;
45101	45194	}
45102		- case 18446744073709549626LLU: // 99999999e4'''''''''''''''
	45195	+ case 18446744073709549624LLU: // 99999999e2'''''''''''''''
45103	45196	{
45104	45197	// ACCUMULATE ARGUMENTS - BEGIN
45105	45198	{

		@@ -45119,7 +45212,7 @@
45119	45212	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45120	45213	}
45121	45214	// ACCUMULATE ARGUMENTS - END
45122		- uint64_t return_to = 18446744073709549624LLU;
	45215	+ uint64_t return_to = 18446744073709549622LLU;
45123	45216	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45124	45217	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45125	45218	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45128,7 +45221,7 @@
45128	45221	state.addr = 819857494882385920LLU; // res_u64___
45129	45222	break;
45130	45223	}
45131		- case 18446744073709549624LLU: // 99999999e2'''''''''''''''
	45224	+ case 18446744073709549622LLU: // 99999999e0'''''''''''''''
45132	45225	{
45133	45226	// ACCUMULATE ARGUMENTS - BEGIN
45134	45227	{

		@@ -45136,7 +45229,7 @@
45136	45229	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45137	45230	}
45138	45231	// ACCUMULATE ARGUMENTS - END
45139		- uint64_t return_to = 18446744073709549623LLU;
	45232	+ uint64_t return_to = 18446744073709549621LLU;
45140	45233	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45141	45234	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45142	45235	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45145,7 +45238,7 @@
45145	45238	state.addr = 839519665163075584LLU; // skip______
45146	45239	break;
45147	45240	}
45148		- case 18446744073709549623LLU: // 99999999e1'''''''''''''''
	45241	+ case 18446744073709549621LLU: // 99999999ez'''''''''''''''
45149	45242	{
45150	45243	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
45151	45244	fprintf(stdout, "%s", "\n ");

		@@ -45171,7 +45264,7 @@
45171	45264	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45172	45265	}
45173	45266	// ACCUMULATE ARGUMENTS - END
45174		- uint64_t return_to = 18446744073709549622LLU;
	45267	+ uint64_t return_to = 18446744073709549620LLU;
45175	45268	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
45176	45269	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45177	45270	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45180,7 +45273,7 @@
45180	45273	state.addr = 587881357514113024LLU; // emitpar___
45181	45274	break;
45182	45275	}
45183		- case 18446744073709549622LLU: // 99999999e0'''''''''''''''
	45276	+ case 18446744073709549620LLU: // 99999999ey'''''''''''''''
45184	45277	{
45185	45278	fprintf(stdout, "%s", " = (uint64_t)getchar();");
45186	45279	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45189,7 +45282,7 @@
45189	45282	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45190	45283	}
45191	45284	// ACCUMULATE ARGUMENTS - END
45192		- uint64_t return_to = 18446744073709549621LLU;
	45285	+ uint64_t return_to = 18446744073709549619LLU;
45193	45286	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45194	45287	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45195	45288	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45198,7 +45291,7 @@
45198	45291	state.addr = 839519665163075584LLU; // skip______
45199	45292	break;
45200	45293	}
45201		- case 18446744073709549621LLU: // 99999999ez'''''''''''''''
	45294	+ case 18446744073709549619LLU: // 99999999ex'''''''''''''''
45202	45295	{
45203	45296	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
45204	45297	// variable resdest___ single____ goes out of scope

		@@ -45209,7 +45302,7 @@
45209	45302	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45210	45303	}
45211	45304	// ACCUMULATE ARGUMENTS - END
45212		- uint64_t return_to = 18446744073709549620LLU;
	45305	+ uint64_t return_to = 18446744073709549618LLU;
45213	45306	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45214	45307	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45215	45308	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45218,13 +45311,13 @@
45218	45311	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
45219	45312	break;
45220	45313	}
45221		- case 18446744073709549620LLU: // 99999999ey'''''''''''''''
	45314	+ case 18446744073709549618LLU: // 99999999ew'''''''''''''''
45222	45315	{
45223	45316	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 17
45224		- state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
	45317	+ state.addr = 18446744073709549625LLU; // 99999999e3'''''''''''''''
45225	45318	break;
45226	45319	}
45227		- case 18446744073709549628LLU: // 99999999e6'''''''''''''''
	45320	+ case 18446744073709549626LLU: // 99999999e4'''''''''''''''
45228	45321	{
45229	45322
45230	45323	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 783769716797919232;

		@@ -45235,11 +45328,11 @@
45235	45328	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
45236	45329	}
45237	45330	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45238		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549619LLU : 18446744073709549618LLU;
	45331	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549617LLU : 18446744073709549616LLU;
45239	45332	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
45240	45333	break;
45241	45334	}
45242		- case 18446744073709549619LLU: // 99999999ex'''''''''''''''
	45335	+ case 18446744073709549617LLU: // 99999999ev'''''''''''''''
45243	45336	{
45244	45337	{
45245	45338	uint64_t arg = 0;

		@@ -45264,7 +45357,7 @@
45264	45357	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45265	45358	}
45266	45359	// ACCUMULATE ARGUMENTS - END
45267		- uint64_t return_to = 18446744073709549615LLU;
	45360	+ uint64_t return_to = 18446744073709549613LLU;
45268	45361	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45269	45362	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45270	45363	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45273,7 +45366,7 @@
45273	45366	state.addr = 861504796319285248LLU; // typeu64___
45274	45367	break;
45275	45368	}
45276		- case 18446744073709549615LLU: // 99999999et'''''''''''''''
	45369	+ case 18446744073709549613LLU: // 99999999er'''''''''''''''
45277	45370	{
45278	45371	{
45279	45372	uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 19*/;

		@@ -45293,7 +45386,7 @@
45293	45386	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45294	45387	}
45295	45388	// ACCUMULATE ARGUMENTS - END
45296		- uint64_t return_to = 18446744073709549616LLU;
	45389	+ uint64_t return_to = 18446744073709549614LLU;
45297	45390	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45298	45391	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45299	45392	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45302,7 +45395,7 @@
45302	45395	state.addr = 819859607768530944LLU; // resdest___
45303	45396	break;
45304	45397	}
45305		- case 18446744073709549616LLU: // 99999999eu'''''''''''''''
	45398	+ case 18446744073709549614LLU: // 99999999es'''''''''''''''
45306	45399	{
45307	45400	// ACCUMULATE ARGUMENTS - BEGIN
45308	45401	{

		@@ -45322,7 +45415,7 @@
45322	45415	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45323	45416	}
45324	45417	// ACCUMULATE ARGUMENTS - END
45325		- uint64_t return_to = 18446744073709549614LLU;
	45418	+ uint64_t return_to = 18446744073709549612LLU;
45326	45419	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45327	45420	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45328	45421	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45331,7 +45424,7 @@
45331	45424	state.addr = 819857494882385920LLU; // res_u64___
45332	45425	break;
45333	45426	}
45334		- case 18446744073709549614LLU: // 99999999es'''''''''''''''
	45427	+ case 18446744073709549612LLU: // 99999999eq'''''''''''''''
45335	45428	{
45336	45429	// ACCUMULATE ARGUMENTS - BEGIN
45337	45430	{

		@@ -45339,7 +45432,7 @@
45339	45432	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45340	45433	}
45341	45434	// ACCUMULATE ARGUMENTS - END
45342		- uint64_t return_to = 18446744073709549613LLU;
	45435	+ uint64_t return_to = 18446744073709549611LLU;
45343	45436	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45344	45437	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45345	45438	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45348,7 +45441,7 @@
45348	45441	state.addr = 839519665163075584LLU; // skip______
45349	45442	break;
45350	45443	}
45351		- case 18446744073709549613LLU: // 99999999er'''''''''''''''
	45444	+ case 18446744073709549611LLU: // 99999999ep'''''''''''''''
45352	45445	{
45353	45446	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
45354	45447	fprintf(stdout, "%s", "\n ");

		@@ -45374,7 +45467,7 @@
45374	45467	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45375	45468	}
45376	45469	// ACCUMULATE ARGUMENTS - END
45377		- uint64_t return_to = 18446744073709549612LLU;
	45470	+ uint64_t return_to = 18446744073709549610LLU;
45378	45471	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
45379	45472	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45380	45473	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45383,7 +45476,7 @@
45383	45476	state.addr = 587881357514113024LLU; // emitpar___
45384	45477	break;
45385	45478	}
45386		- case 18446744073709549612LLU: // 99999999eq'''''''''''''''
	45479	+ case 18446744073709549610LLU: // 99999999eo'''''''''''''''
45387	45480	{
45388	45481	fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
45389	45482	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45392,7 +45485,7 @@
45392	45485	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45393	45486	}
45394	45487	// ACCUMULATE ARGUMENTS - END
45395		- uint64_t return_to = 18446744073709549611LLU;
	45488	+ uint64_t return_to = 18446744073709549609LLU;
45396	45489	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45397	45490	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45398	45491	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45401,7 +45494,7 @@
45401	45494	state.addr = 839519665163075584LLU; // skip______
45402	45495	break;
45403	45496	}
45404		- case 18446744073709549611LLU: // 99999999ep'''''''''''''''
	45497	+ case 18446744073709549609LLU: // 99999999en'''''''''''''''
45405	45498	{
45406	45499	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
45407	45500	// variable resdest___ single____ goes out of scope

		@@ -45412,7 +45505,7 @@
45412	45505	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45413	45506	}
45414	45507	// ACCUMULATE ARGUMENTS - END
45415		- uint64_t return_to = 18446744073709549610LLU;
	45508	+ uint64_t return_to = 18446744073709549608LLU;
45416	45509	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45417	45510	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45418	45511	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45421,23 +45514,23 @@
45421	45514	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
45422	45515	break;
45423	45516	}
45424		- case 18446744073709549610LLU: // 99999999eo'''''''''''''''
	45517	+ case 18446744073709549608LLU: // 99999999em'''''''''''''''
45425	45518	{
45426	45519	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 17
45427		- state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
	45520	+ state.addr = 18446744073709549615LLU; // 99999999et'''''''''''''''
45428	45521	break;
45429	45522	}
45430		- case 18446744073709549618LLU: // 99999999ew'''''''''''''''
	45523	+ case 18446744073709549616LLU: // 99999999eu'''''''''''''''
45431	45524	{
45432		- state.addr = 18446744073709549617LLU; // 99999999ev'''''''''''''''
	45525	+ state.addr = 18446744073709549615LLU; // 99999999et'''''''''''''''
45433	45526	break;
45434	45527	}
45435		- case 18446744073709549617LLU: // 99999999ev'''''''''''''''
	45528	+ case 18446744073709549615LLU: // 99999999et'''''''''''''''
45436	45529	{
45437		- state.addr = 18446744073709549627LLU; // 99999999e5'''''''''''''''
	45530	+ state.addr = 18446744073709549625LLU; // 99999999e3'''''''''''''''
45438	45531	break;
45439	45532	}
45440		- case 18446744073709549627LLU: // 99999999e5'''''''''''''''
	45533	+ case 18446744073709549625LLU: // 99999999e3'''''''''''''''
45441	45534	{
45442	45535	// variable u64 sym_______ goes out of scope
45443	45536	// emitted destructur for type u64

		@@ -45496,11 +45589,11 @@
45496	45589	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
45497	45590	}
45498	45591	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45499		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549609LLU : 18446744073709549608LLU;
	45592	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549607LLU : 18446744073709549606LLU;
45500	45593	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
45501	45594	break;
45502	45595	}
45503		- case 18446744073709549609LLU: // 99999999en'''''''''''''''
	45596	+ case 18446744073709549607LLU: // 99999999el'''''''''''''''
45504	45597	{
45505	45598	{
45506	45599	uint64_t arg = 0;

		@@ -45527,7 +45620,7 @@
45527	45620	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45528	45621	}
45529	45622	// ACCUMULATE ARGUMENTS - END
45530		- uint64_t return_to = 18446744073709549606LLU;
	45623	+ uint64_t return_to = 18446744073709549604LLU;
45531	45624	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45532	45625	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45533	45626	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45536,7 +45629,7 @@
45536	45629	state.addr = 861504796319285248LLU; // typeu64___
45537	45630	break;
45538	45631	}
45539		- case 18446744073709549606LLU: // 99999999ek'''''''''''''''
	45632	+ case 18446744073709549604LLU: // 99999999ei'''''''''''''''
45540	45633	{
45541	45634	{
45542	45635	uint64_t arg = 0;

		@@ -45561,7 +45654,7 @@
45561	45654	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45562	45655	}
45563	45656	// ACCUMULATE ARGUMENTS - END
45564		- uint64_t return_to = 18446744073709549604LLU;
	45657	+ uint64_t return_to = 18446744073709549602LLU;
45565	45658	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45566	45659	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45567	45660	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45570,7 +45663,7 @@
45570	45663	state.addr = 861504796319285248LLU; // typeu64___
45571	45664	break;
45572	45665	}
45573		- case 18446744073709549604LLU: // 99999999ei'''''''''''''''
	45666	+ case 18446744073709549602LLU: // 99999999eg'''''''''''''''
45574	45667	{
45575	45668	{
45576	45669	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -45590,7 +45683,7 @@
45590	45683	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45591	45684	}
45592	45685	// ACCUMULATE ARGUMENTS - END
45593		- uint64_t return_to = 18446744073709549605LLU;
	45686	+ uint64_t return_to = 18446744073709549603LLU;
45594	45687	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45595	45688	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45596	45689	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45599,7 +45692,7 @@
45599	45692	state.addr = 819859607768530944LLU; // resdest___
45600	45693	break;
45601	45694	}
45602		- case 18446744073709549605LLU: // 99999999ej'''''''''''''''
	45695	+ case 18446744073709549603LLU: // 99999999eh'''''''''''''''
45603	45696	{
45604	45697	// ACCUMULATE ARGUMENTS - BEGIN
45605	45698	{

		@@ -45619,7 +45712,7 @@
45619	45712	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45620	45713	}
45621	45714	// ACCUMULATE ARGUMENTS - END
45622		- uint64_t return_to = 18446744073709549603LLU;
	45715	+ uint64_t return_to = 18446744073709549601LLU;
45623	45716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45624	45717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45625	45718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45628,7 +45721,7 @@
45628	45721	state.addr = 819857494882385920LLU; // res_u64___
45629	45722	break;
45630	45723	}
45631		- case 18446744073709549603LLU: // 99999999eh'''''''''''''''
	45724	+ case 18446744073709549601LLU: // 99999999ef'''''''''''''''
45632	45725	{
45633	45726	// ACCUMULATE ARGUMENTS - BEGIN
45634	45727	{

		@@ -45636,7 +45729,7 @@
45636	45729	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45637	45730	}
45638	45731	// ACCUMULATE ARGUMENTS - END
45639		- uint64_t return_to = 18446744073709549602LLU;
	45732	+ uint64_t return_to = 18446744073709549600LLU;
45640	45733	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45641	45734	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45642	45735	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45645,7 +45738,7 @@
45645	45738	state.addr = 839519665163075584LLU; // skip______
45646	45739	break;
45647	45740	}
45648		- case 18446744073709549602LLU: // 99999999eg'''''''''''''''
	45741	+ case 18446744073709549600LLU: // 99999999ee'''''''''''''''
45649	45742	{
45650	45743	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
45651	45744	fprintf(stdout, "%s", "\n ");

		@@ -45671,7 +45764,7 @@
45671	45764	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45672	45765	}
45673	45766	// ACCUMULATE ARGUMENTS - END
45674		- uint64_t return_to = 18446744073709549601LLU;
	45767	+ uint64_t return_to = 18446744073709549599LLU;
45675	45768	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
45676	45769	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45677	45770	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45680,7 +45773,7 @@
45680	45773	state.addr = 587881357514113024LLU; // emitpar___
45681	45774	break;
45682	45775	}
45683		- case 18446744073709549601LLU: // 99999999ef'''''''''''''''
	45776	+ case 18446744073709549599LLU: // 99999999ed'''''''''''''''
45684	45777	{
45685	45778	fprintf(stdout, "%s", " = ~");
45686	45779	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -45689,7 +45782,7 @@
45689	45782	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45690	45783	}
45691	45784	// ACCUMULATE ARGUMENTS - END
45692		- uint64_t return_to = 18446744073709549600LLU;
	45785	+ uint64_t return_to = 18446744073709549598LLU;
45693	45786	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45694	45787	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45695	45788	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45698,7 +45791,7 @@
45698	45791	state.addr = 839519665163075584LLU; // skip______
45699	45792	break;
45700	45793	}
45701		- case 18446744073709549600LLU: // 99999999ee'''''''''''''''
	45794	+ case 18446744073709549598LLU: // 99999999ec'''''''''''''''
45702	45795	{
45703	45796
45704	45797	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -45720,7 +45813,7 @@
45720	45813	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45721	45814	}
45722	45815	// ACCUMULATE ARGUMENTS - END
45723		- uint64_t return_to = 18446744073709549599LLU;
	45816	+ uint64_t return_to = 18446744073709549597LLU;
45724	45817	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
45725	45818	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45726	45819	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45729,7 +45822,7 @@
45729	45822	state.addr = 23446349213393492LLU; // ASSERTINIT
45730	45823	break;
45731	45824	}
45732		- case 18446744073709549599LLU: // 99999999ed'''''''''''''''
	45825	+ case 18446744073709549597LLU: // 99999999eb'''''''''''''''
45733	45826	{
45734	45827	{
45735	45828	uint64_t arg = 0;

		@@ -45808,7 +45901,7 @@
45808	45901	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45809	45902	}
45810	45903	// ACCUMULATE ARGUMENTS - END
45811		- uint64_t return_to = 18446744073709549598LLU;
	45904	+ uint64_t return_to = 18446744073709549596LLU;
45812	45905	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
45813	45906	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45814	45907	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45817,7 +45910,7 @@
45817	45910	state.addr = 293363126232490310LLU; // PROCVARREF
45818	45911	break;
45819	45912	}
45820		- case 18446744073709549598LLU: // 99999999ec'''''''''''''''
	45913	+ case 18446744073709549596LLU: // 99999999ea'''''''''''''''
45821	45914	{
45822	45915	// variable u64 initialize goes out of scope
45823	45916	// emitted destructur for type u64

		@@ -45838,7 +45931,7 @@
45838	45931	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45839	45932	}
45840	45933	// ACCUMULATE ARGUMENTS - END
45841		- uint64_t return_to = 18446744073709549597LLU;
	45934	+ uint64_t return_to = 18446744073709549595LLU;
45842	45935	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
45843	45936	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45844	45937	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45847,7 +45940,7 @@
45847	45940	state.addr = 517555565476695680LLU; // assertu64_
45848	45941	break;
45849	45942	}
45850		- case 18446744073709549597LLU: // 99999999eb'''''''''''''''
	45943	+ case 18446744073709549595LLU: // 99999999e$'''''''''''''''
45851	45944	{
45852	45945	// ACCUMULATE ARGUMENTS - BEGIN
45853	45946	{

		@@ -45855,7 +45948,7 @@
45855	45948	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45856	45949	}
45857	45950	// ACCUMULATE ARGUMENTS - END
45858		- uint64_t return_to = 18446744073709549596LLU;
	45951	+ uint64_t return_to = 18446744073709549594LLU;
45859	45952	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45860	45953	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45861	45954	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45864,7 +45957,7 @@
45864	45957	state.addr = 839519665163075584LLU; // skip______
45865	45958	break;
45866	45959	}
45867		- case 18446744073709549596LLU: // 99999999ea'''''''''''''''
	45960	+ case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
45868	45961	{
45869	45962	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
45870	45963	fprintf(stdout, "%s", ";");

		@@ -45876,7 +45969,7 @@
45876	45969	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45877	45970	}
45878	45971	// ACCUMULATE ARGUMENTS - END
45879		- uint64_t return_to = 18446744073709549595LLU;
	45972	+ uint64_t return_to = 18446744073709549593LLU;
45880	45973	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45881	45974	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45882	45975	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45885,7 +45978,7 @@
45885	45978	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
45886	45979	break;
45887	45980	}
45888		- case 18446744073709549595LLU: // 99999999e$'''''''''''''''
	45981	+ case 18446744073709549593LLU: // 99999999eY'''''''''''''''
45889	45982	{
45890	45983	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
45891	45984	// variable type______ type______ goes out of scope

		@@ -45896,7 +45989,7 @@
45896	45989	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45897	45990	}
45898	45991	// ACCUMULATE ARGUMENTS - END
45899		- uint64_t return_to = 18446744073709549594LLU;
	45992	+ uint64_t return_to = 18446744073709549592LLU;
45900	45993	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45901	45994	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45902	45995	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45905,7 +45998,7 @@
45905	45998	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
45906	45999	break;
45907	46000	}
45908		- case 18446744073709549594LLU: // 99999999eZ'''''''''''''''
	46001	+ case 18446744073709549592LLU: // 99999999eX'''''''''''''''
45909	46002	{
45910	46003	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
45911	46004	// variable u64 mutable___ goes out of scope

		@@ -45917,10 +46010,10 @@
45917	46010	// variable u64 id________ goes out of scope
45918	46011	// emitted destructur for type u64
45919	46012	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
45920		- state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
	46013	+ state.addr = 18446744073709549605LLU; // 99999999ej'''''''''''''''
45921	46014	break;
45922	46015	}
45923		- case 18446744073709549608LLU: // 99999999em'''''''''''''''
	46016	+ case 18446744073709549606LLU: // 99999999ek'''''''''''''''
45924	46017	{
45925	46018
45926	46019	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750618996096630784;

		@@ -45931,11 +46024,11 @@
45931	46024	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
45932	46025	}
45933	46026	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
45934		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549593LLU : 18446744073709549592LLU;
	46027	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549591LLU : 18446744073709549590LLU;
45935	46028	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
45936	46029	break;
45937	46030	}
45938		- case 18446744073709549593LLU: // 99999999eY'''''''''''''''
	46031	+ case 18446744073709549591LLU: // 99999999eW'''''''''''''''
45939	46032	{
45940	46033	{
45941	46034	uint64_t arg = 0;

		@@ -45962,7 +46055,7 @@
45962	46055	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45963	46056	}
45964	46057	// ACCUMULATE ARGUMENTS - END
45965		- uint64_t return_to = 18446744073709549590LLU;
	46058	+ uint64_t return_to = 18446744073709549588LLU;
45966	46059	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
45967	46060	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
45968	46061	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -45971,7 +46064,7 @@
45971	46064	state.addr = 861504796319285248LLU; // typeu64___
45972	46065	break;
45973	46066	}
45974		- case 18446744073709549590LLU: // 99999999eV'''''''''''''''
	46067	+ case 18446744073709549588LLU: // 99999999eT'''''''''''''''
45975	46068	{
45976	46069	{
45977	46070	uint64_t arg = 0;

		@@ -45996,7 +46089,7 @@
45996	46089	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
45997	46090	}
45998	46091	// ACCUMULATE ARGUMENTS - END
45999		- uint64_t return_to = 18446744073709549588LLU;
	46092	+ uint64_t return_to = 18446744073709549586LLU;
46000	46093	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46001	46094	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46002	46095	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46005,7 +46098,7 @@
46005	46098	state.addr = 861504796319285248LLU; // typeu64___
46006	46099	break;
46007	46100	}
46008		- case 18446744073709549588LLU: // 99999999eT'''''''''''''''
	46101	+ case 18446744073709549586LLU: // 99999999eR'''''''''''''''
46009	46102	{
46010	46103	{
46011	46104	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -46025,7 +46118,7 @@
46025	46118	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46026	46119	}
46027	46120	// ACCUMULATE ARGUMENTS - END
46028		- uint64_t return_to = 18446744073709549589LLU;
	46121	+ uint64_t return_to = 18446744073709549587LLU;
46029	46122	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46030	46123	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46031	46124	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46034,7 +46127,7 @@
46034	46127	state.addr = 819859607768530944LLU; // resdest___
46035	46128	break;
46036	46129	}
46037		- case 18446744073709549589LLU: // 99999999eU'''''''''''''''
	46130	+ case 18446744073709549587LLU: // 99999999eS'''''''''''''''
46038	46131	{
46039	46132	// ACCUMULATE ARGUMENTS - BEGIN
46040	46133	{

		@@ -46054,7 +46147,7 @@
46054	46147	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46055	46148	}
46056	46149	// ACCUMULATE ARGUMENTS - END
46057		- uint64_t return_to = 18446744073709549587LLU;
	46150	+ uint64_t return_to = 18446744073709549585LLU;
46058	46151	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46059	46152	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46060	46153	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46063,7 +46156,7 @@
46063	46156	state.addr = 819857494882385920LLU; // res_u64___
46064	46157	break;
46065	46158	}
46066		- case 18446744073709549587LLU: // 99999999eS'''''''''''''''
	46159	+ case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
46067	46160	{
46068	46161	// ACCUMULATE ARGUMENTS - BEGIN
46069	46162	{

		@@ -46071,7 +46164,7 @@
46071	46164	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46072	46165	}
46073	46166	// ACCUMULATE ARGUMENTS - END
46074		- uint64_t return_to = 18446744073709549586LLU;
	46167	+ uint64_t return_to = 18446744073709549584LLU;
46075	46168	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46076	46169	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46077	46170	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46080,7 +46173,7 @@
46080	46173	state.addr = 839519665163075584LLU; // skip______
46081	46174	break;
46082	46175	}
46083		- case 18446744073709549586LLU: // 99999999eR'''''''''''''''
	46176	+ case 18446744073709549584LLU: // 99999999eP'''''''''''''''
46084	46177	{
46085	46178	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
46086	46179	fprintf(stdout, "%s", "\n ");

		@@ -46106,7 +46199,7 @@
46106	46199	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46107	46200	}
46108	46201	// ACCUMULATE ARGUMENTS - END
46109		- uint64_t return_to = 18446744073709549585LLU;
	46202	+ uint64_t return_to = 18446744073709549583LLU;
46110	46203	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
46111	46204	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46112	46205	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46115,7 +46208,7 @@
46115	46208	state.addr = 587881357514113024LLU; // emitpar___
46116	46209	break;
46117	46210	}
46118		- case 18446744073709549585LLU: // 99999999eQ'''''''''''''''
	46211	+ case 18446744073709549583LLU: // 99999999eO'''''''''''''''
46119	46212	{
46120	46213	fprintf(stdout, "%s", " = !");
46121	46214	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46124,7 +46217,7 @@
46124	46217	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46125	46218	}
46126	46219	// ACCUMULATE ARGUMENTS - END
46127		- uint64_t return_to = 18446744073709549584LLU;
	46220	+ uint64_t return_to = 18446744073709549582LLU;
46128	46221	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46129	46222	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46130	46223	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46133,7 +46226,7 @@
46133	46226	state.addr = 839519665163075584LLU; // skip______
46134	46227	break;
46135	46228	}
46136		- case 18446744073709549584LLU: // 99999999eP'''''''''''''''
	46229	+ case 18446744073709549582LLU: // 99999999eN'''''''''''''''
46137	46230	{
46138	46231
46139	46232	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -46155,7 +46248,7 @@
46155	46248	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46156	46249	}
46157	46250	// ACCUMULATE ARGUMENTS - END
46158		- uint64_t return_to = 18446744073709549583LLU;
	46251	+ uint64_t return_to = 18446744073709549581LLU;
46159	46252	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46160	46253	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46161	46254	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46164,7 +46257,7 @@
46164	46257	state.addr = 23446349213393492LLU; // ASSERTINIT
46165	46258	break;
46166	46259	}
46167		- case 18446744073709549583LLU: // 99999999eO'''''''''''''''
	46260	+ case 18446744073709549581LLU: // 99999999eM'''''''''''''''
46168	46261	{
46169	46262	{
46170	46263	uint64_t arg = 0;

		@@ -46243,7 +46336,7 @@
46243	46336	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46244	46337	}
46245	46338	// ACCUMULATE ARGUMENTS - END
46246		- uint64_t return_to = 18446744073709549582LLU;
	46339	+ uint64_t return_to = 18446744073709549580LLU;
46247	46340	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
46248	46341	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46249	46342	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46252,7 +46345,7 @@
46252	46345	state.addr = 293363126232490310LLU; // PROCVARREF
46253	46346	break;
46254	46347	}
46255		- case 18446744073709549582LLU: // 99999999eN'''''''''''''''
	46348	+ case 18446744073709549580LLU: // 99999999eL'''''''''''''''
46256	46349	{
46257	46350	// variable u64 initialize goes out of scope
46258	46351	// emitted destructur for type u64

		@@ -46273,7 +46366,7 @@
46273	46366	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46274	46367	}
46275	46368	// ACCUMULATE ARGUMENTS - END
46276		- uint64_t return_to = 18446744073709549581LLU;
	46369	+ uint64_t return_to = 18446744073709549579LLU;
46277	46370	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46278	46371	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46279	46372	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46282,7 +46375,7 @@
46282	46375	state.addr = 517555565476695680LLU; // assertu64_
46283	46376	break;
46284	46377	}
46285		- case 18446744073709549581LLU: // 99999999eM'''''''''''''''
	46378	+ case 18446744073709549579LLU: // 99999999eK'''''''''''''''
46286	46379	{
46287	46380	// ACCUMULATE ARGUMENTS - BEGIN
46288	46381	{

		@@ -46290,7 +46383,7 @@
46290	46383	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46291	46384	}
46292	46385	// ACCUMULATE ARGUMENTS - END
46293		- uint64_t return_to = 18446744073709549580LLU;
	46386	+ uint64_t return_to = 18446744073709549578LLU;
46294	46387	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46295	46388	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46296	46389	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46299,7 +46392,7 @@
46299	46392	state.addr = 839519665163075584LLU; // skip______
46300	46393	break;
46301	46394	}
46302		- case 18446744073709549580LLU: // 99999999eL'''''''''''''''
	46395	+ case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
46303	46396	{
46304	46397	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
46305	46398	fprintf(stdout, "%s", ";");

		@@ -46311,7 +46404,7 @@
46311	46404	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46312	46405	}
46313	46406	// ACCUMULATE ARGUMENTS - END
46314		- uint64_t return_to = 18446744073709549579LLU;
	46407	+ uint64_t return_to = 18446744073709549577LLU;
46315	46408	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46316	46409	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46317	46410	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46320,7 +46413,7 @@
46320	46413	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
46321	46414	break;
46322	46415	}
46323		- case 18446744073709549579LLU: // 99999999eK'''''''''''''''
	46416	+ case 18446744073709549577LLU: // 99999999eI'''''''''''''''
46324	46417	{
46325	46418	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
46326	46419	// variable type______ type______ goes out of scope

		@@ -46331,7 +46424,7 @@
46331	46424	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46332	46425	}
46333	46426	// ACCUMULATE ARGUMENTS - END
46334		- uint64_t return_to = 18446744073709549578LLU;
	46427	+ uint64_t return_to = 18446744073709549576LLU;
46335	46428	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46336	46429	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46337	46430	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46340,7 +46433,7 @@
46340	46433	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
46341	46434	break;
46342	46435	}
46343		- case 18446744073709549578LLU: // 99999999eJ'''''''''''''''
	46436	+ case 18446744073709549576LLU: // 99999999eH'''''''''''''''
46344	46437	{
46345	46438	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
46346	46439	// variable u64 mutable___ goes out of scope

		@@ -46352,10 +46445,10 @@
46352	46445	// variable u64 id________ goes out of scope
46353	46446	// emitted destructur for type u64
46354	46447	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
46355		- state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
	46448	+ state.addr = 18446744073709549589LLU; // 99999999eU'''''''''''''''
46356	46449	break;
46357	46450	}
46358		- case 18446744073709549592LLU: // 99999999eX'''''''''''''''
	46451	+ case 18446744073709549590LLU: // 99999999eV'''''''''''''''
46359	46452	{
46360	46453
46361	46454	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543416397824;

		@@ -46366,11 +46459,11 @@
46366	46459	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
46367	46460	}
46368	46461	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46369		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549577LLU : 18446744073709549576LLU;
	46462	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549575LLU : 18446744073709549574LLU;
46370	46463	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
46371	46464	break;
46372	46465	}
46373		- case 18446744073709549577LLU: // 99999999eI'''''''''''''''
	46466	+ case 18446744073709549575LLU: // 99999999eG'''''''''''''''
46374	46467	{
46375	46468	{
46376	46469	uint64_t arg = 0;

		@@ -46397,7 +46490,7 @@
46397	46490	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46398	46491	}
46399	46492	// ACCUMULATE ARGUMENTS - END
46400		- uint64_t return_to = 18446744073709549574LLU;
	46493	+ uint64_t return_to = 18446744073709549572LLU;
46401	46494	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46402	46495	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46403	46496	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46406,7 +46499,7 @@
46406	46499	state.addr = 861504796319285248LLU; // typeu64___
46407	46500	break;
46408	46501	}
46409		- case 18446744073709549574LLU: // 99999999eF'''''''''''''''
	46502	+ case 18446744073709549572LLU: // 99999999eD'''''''''''''''
46410	46503	{
46411	46504	{
46412	46505	uint64_t arg = 0;

		@@ -46431,7 +46524,7 @@
46431	46524	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46432	46525	}
46433	46526	// ACCUMULATE ARGUMENTS - END
46434		- uint64_t return_to = 18446744073709549572LLU;
	46527	+ uint64_t return_to = 18446744073709549570LLU;
46435	46528	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46436	46529	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46437	46530	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46440,7 +46533,7 @@
46440	46533	state.addr = 861504796319285248LLU; // typeu64___
46441	46534	break;
46442	46535	}
46443		- case 18446744073709549572LLU: // 99999999eD'''''''''''''''
	46536	+ case 18446744073709549570LLU: // 99999999eB'''''''''''''''
46444	46537	{
46445	46538	{
46446	46539	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -46460,7 +46553,7 @@
46460	46553	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46461	46554	}
46462	46555	// ACCUMULATE ARGUMENTS - END
46463		- uint64_t return_to = 18446744073709549573LLU;
	46556	+ uint64_t return_to = 18446744073709549571LLU;
46464	46557	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46465	46558	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46466	46559	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46469,7 +46562,7 @@
46469	46562	state.addr = 819859607768530944LLU; // resdest___
46470	46563	break;
46471	46564	}
46472		- case 18446744073709549573LLU: // 99999999eE'''''''''''''''
	46565	+ case 18446744073709549571LLU: // 99999999eC'''''''''''''''
46473	46566	{
46474	46567	// ACCUMULATE ARGUMENTS - BEGIN
46475	46568	{

		@@ -46489,7 +46582,7 @@
46489	46582	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46490	46583	}
46491	46584	// ACCUMULATE ARGUMENTS - END
46492		- uint64_t return_to = 18446744073709549571LLU;
	46585	+ uint64_t return_to = 18446744073709549569LLU;
46493	46586	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46494	46587	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46495	46588	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46498,7 +46591,7 @@
46498	46591	state.addr = 819857494882385920LLU; // res_u64___
46499	46592	break;
46500	46593	}
46501		- case 18446744073709549571LLU: // 99999999eC'''''''''''''''
	46594	+ case 18446744073709549569LLU: // 99999999eA'''''''''''''''
46502	46595	{
46503	46596	// ACCUMULATE ARGUMENTS - BEGIN
46504	46597	{

		@@ -46506,7 +46599,7 @@
46506	46599	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46507	46600	}
46508	46601	// ACCUMULATE ARGUMENTS - END
46509		- uint64_t return_to = 18446744073709549570LLU;
	46602	+ uint64_t return_to = 18446744073709549568LLU;
46510	46603	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46511	46604	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46512	46605	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46515,7 +46608,7 @@
46515	46608	state.addr = 839519665163075584LLU; // skip______
46516	46609	break;
46517	46610	}
46518		- case 18446744073709549570LLU: // 99999999eB'''''''''''''''
	46611	+ case 18446744073709549568LLU: // 99999999e_'''''''''''''''
46519	46612	{
46520	46613	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
46521	46614	fprintf(stdout, "%s", "\n ");

		@@ -46541,7 +46634,7 @@
46541	46634	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46542	46635	}
46543	46636	// ACCUMULATE ARGUMENTS - END
46544		- uint64_t return_to = 18446744073709549569LLU;
	46637	+ uint64_t return_to = 18446744073709549567LLU;
46545	46638	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
46546	46639	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46547	46640	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46550,7 +46643,7 @@
46550	46643	state.addr = 587881357514113024LLU; // emitpar___
46551	46644	break;
46552	46645	}
46553		- case 18446744073709549569LLU: // 99999999eA'''''''''''''''
	46646	+ case 18446744073709549567LLU: // 99999999d9'''''''''''''''
46554	46647	{
46555	46648	fprintf(stdout, "%s", " = parseid(&");
46556	46649	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46559,7 +46652,7 @@
46559	46652	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46560	46653	}
46561	46654	// ACCUMULATE ARGUMENTS - END
46562		- uint64_t return_to = 18446744073709549568LLU;
	46655	+ uint64_t return_to = 18446744073709549566LLU;
46563	46656	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46564	46657	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46565	46658	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46568,7 +46661,7 @@
46568	46661	state.addr = 839519665163075584LLU; // skip______
46569	46662	break;
46570	46663	}
46571		- case 18446744073709549568LLU: // 99999999e_'''''''''''''''
	46664	+ case 18446744073709549566LLU: // 99999999d8'''''''''''''''
46572	46665	{
46573	46666
46574	46667	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -46590,7 +46683,7 @@
46590	46683	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46591	46684	}
46592	46685	// ACCUMULATE ARGUMENTS - END
46593		- uint64_t return_to = 18446744073709549567LLU;
	46686	+ uint64_t return_to = 18446744073709549565LLU;
46594	46687	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46595	46688	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46596	46689	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46599,7 +46692,7 @@
46599	46692	state.addr = 23446349213393492LLU; // ASSERTINIT
46600	46693	break;
46601	46694	}
46602		- case 18446744073709549567LLU: // 99999999d9'''''''''''''''
	46695	+ case 18446744073709549565LLU: // 99999999d7'''''''''''''''
46603	46696	{
46604	46697	{
46605	46698	uint64_t arg = 0;

		@@ -46678,7 +46771,7 @@
46678	46771	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46679	46772	}
46680	46773	// ACCUMULATE ARGUMENTS - END
46681		- uint64_t return_to = 18446744073709549566LLU;
	46774	+ uint64_t return_to = 18446744073709549564LLU;
46682	46775	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
46683	46776	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46684	46777	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46687,7 +46780,7 @@
46687	46780	state.addr = 293363126232490310LLU; // PROCVARREF
46688	46781	break;
46689	46782	}
46690		- case 18446744073709549566LLU: // 99999999d8'''''''''''''''
	46783	+ case 18446744073709549564LLU: // 99999999d6'''''''''''''''
46691	46784	{
46692	46785	// variable u64 initialize goes out of scope
46693	46786	// emitted destructur for type u64

		@@ -46708,7 +46801,7 @@
46708	46801	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46709	46802	}
46710	46803	// ACCUMULATE ARGUMENTS - END
46711		- uint64_t return_to = 18446744073709549565LLU;
	46804	+ uint64_t return_to = 18446744073709549563LLU;
46712	46805	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46713	46806	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46714	46807	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46717,7 +46810,7 @@
46717	46810	state.addr = 517555565476695680LLU; // assertu64_
46718	46811	break;
46719	46812	}
46720		- case 18446744073709549565LLU: // 99999999d7'''''''''''''''
	46813	+ case 18446744073709549563LLU: // 99999999d5'''''''''''''''
46721	46814	{
46722	46815	fprintf(stdout, "%s", ");");
46723	46816	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46726,7 +46819,7 @@
46726	46819	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46727	46820	}
46728	46821	// ACCUMULATE ARGUMENTS - END
46729		- uint64_t return_to = 18446744073709549564LLU;
	46822	+ uint64_t return_to = 18446744073709549562LLU;
46730	46823	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46731	46824	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46732	46825	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46735,7 +46828,7 @@
46735	46828	state.addr = 839519665163075584LLU; // skip______
46736	46829	break;
46737	46830	}
46738		- case 18446744073709549564LLU: // 99999999d6'''''''''''''''
	46831	+ case 18446744073709549562LLU: // 99999999d4'''''''''''''''
46739	46832	{
46740	46833	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
46741	46834	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -46748,7 +46841,7 @@
46748	46841	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46749	46842	}
46750	46843	// ACCUMULATE ARGUMENTS - END
46751		- uint64_t return_to = 18446744073709549563LLU;
	46844	+ uint64_t return_to = 18446744073709549561LLU;
46752	46845	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
46753	46846	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46754	46847	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46757,7 +46850,7 @@
46757	46850	state.addr = 517555565476695680LLU; // assertu64_
46758	46851	break;
46759	46852	}
46760		- case 18446744073709549563LLU: // 99999999d5'''''''''''''''
	46853	+ case 18446744073709549561LLU: // 99999999d3'''''''''''''''
46761	46854	{
46762	46855	{
46763	46856	uint64_t arg = 0;

		@@ -46786,7 +46879,7 @@
46786	46879	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46787	46880	}
46788	46881	// ACCUMULATE ARGUMENTS - END
46789		- uint64_t return_to = 18446744073709549562LLU;
	46882	+ uint64_t return_to = 18446744073709549560LLU;
46790	46883	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
46791	46884	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46792	46885	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46795,7 +46888,7 @@
46795	46888	state.addr = 734295421765213120LLU; // mutassert_
46796	46889	break;
46797	46890	}
46798		- case 18446744073709549562LLU: // 99999999d4'''''''''''''''
	46891	+ case 18446744073709549560LLU: // 99999999d2'''''''''''''''
46799	46892	{
46800	46893	// variable u64 parnr_____ goes out of scope
46801	46894	// emitted destructur for type u64

		@@ -46808,7 +46901,7 @@
46808	46901	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46809	46902	}
46810	46903	// ACCUMULATE ARGUMENTS - END
46811		- uint64_t return_to = 18446744073709549561LLU;
	46904	+ uint64_t return_to = 18446744073709549559LLU;
46812	46905	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46813	46906	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46814	46907	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46817,7 +46910,7 @@
46817	46910	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
46818	46911	break;
46819	46912	}
46820		- case 18446744073709549561LLU: // 99999999d3'''''''''''''''
	46913	+ case 18446744073709549559LLU: // 99999999d1'''''''''''''''
46821	46914	{
46822	46915	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
46823	46916	// variable type______ type______ goes out of scope

		@@ -46828,7 +46921,7 @@
46828	46921	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46829	46922	}
46830	46923	// ACCUMULATE ARGUMENTS - END
46831		- uint64_t return_to = 18446744073709549560LLU;
	46924	+ uint64_t return_to = 18446744073709549558LLU;
46832	46925	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46833	46926	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46834	46927	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46837,7 +46930,7 @@
46837	46930	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
46838	46931	break;
46839	46932	}
46840		- case 18446744073709549560LLU: // 99999999d2'''''''''''''''
	46933	+ case 18446744073709549558LLU: // 99999999d0'''''''''''''''
46841	46934	{
46842	46935	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
46843	46936	// variable u64 mutable___ goes out of scope

		@@ -46849,10 +46942,10 @@
46849	46942	// variable u64 id________ goes out of scope
46850	46943	// emitted destructur for type u64
46851	46944	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
46852		- state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
	46945	+ state.addr = 18446744073709549573LLU; // 99999999eE'''''''''''''''
46853	46946	break;
46854	46947	}
46855		- case 18446744073709549576LLU: // 99999999eH'''''''''''''''
	46948	+ case 18446744073709549574LLU: // 99999999eF'''''''''''''''
46856	46949	{
46857	46950
46858	46951	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 782701543503953920;

		@@ -46863,11 +46956,11 @@
46863	46956	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
46864	46957	}
46865	46958	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
46866		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549559LLU : 18446744073709549558LLU;
	46959	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549557LLU : 18446744073709549556LLU;
46867	46960	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
46868	46961	break;
46869	46962	}
46870		- case 18446744073709549559LLU: // 99999999d1'''''''''''''''
	46963	+ case 18446744073709549557LLU: // 99999999dz'''''''''''''''
46871	46964	{
46872	46965	{
46873	46966	uint64_t arg = 0;

		@@ -46894,7 +46987,7 @@
46894	46987	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46895	46988	}
46896	46989	// ACCUMULATE ARGUMENTS - END
46897		- uint64_t return_to = 18446744073709549556LLU;
	46990	+ uint64_t return_to = 18446744073709549554LLU;
46898	46991	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46899	46992	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46900	46993	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46903,7 +46996,7 @@
46903	46996	state.addr = 861504796319285248LLU; // typeu64___
46904	46997	break;
46905	46998	}
46906		- case 18446744073709549556LLU: // 99999999dy'''''''''''''''
	46999	+ case 18446744073709549554LLU: // 99999999dw'''''''''''''''
46907	47000	{
46908	47001	{
46909	47002	uint64_t arg = 0;

		@@ -46928,7 +47021,7 @@
46928	47021	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46929	47022	}
46930	47023	// ACCUMULATE ARGUMENTS - END
46931		- uint64_t return_to = 18446744073709549554LLU;
	47024	+ uint64_t return_to = 18446744073709549552LLU;
46932	47025	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
46933	47026	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46934	47027	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46937,7 +47030,7 @@
46937	47030	state.addr = 861504796319285248LLU; // typeu64___
46938	47031	break;
46939	47032	}
46940		- case 18446744073709549554LLU: // 99999999dw'''''''''''''''
	47033	+ case 18446744073709549552LLU: // 99999999du'''''''''''''''
46941	47034	{
46942	47035	{
46943	47036	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -46957,7 +47050,7 @@
46957	47050	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46958	47051	}
46959	47052	// ACCUMULATE ARGUMENTS - END
46960		- uint64_t return_to = 18446744073709549555LLU;
	47053	+ uint64_t return_to = 18446744073709549553LLU;
46961	47054	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46962	47055	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46963	47056	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46966,7 +47059,7 @@
46966	47059	state.addr = 819859607768530944LLU; // resdest___
46967	47060	break;
46968	47061	}
46969		- case 18446744073709549555LLU: // 99999999dx'''''''''''''''
	47062	+ case 18446744073709549553LLU: // 99999999dv'''''''''''''''
46970	47063	{
46971	47064	// ACCUMULATE ARGUMENTS - BEGIN
46972	47065	{

		@@ -46986,7 +47079,7 @@
46986	47079	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
46987	47080	}
46988	47081	// ACCUMULATE ARGUMENTS - END
46989		- uint64_t return_to = 18446744073709549553LLU;
	47082	+ uint64_t return_to = 18446744073709549551LLU;
46990	47083	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
46991	47084	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
46992	47085	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -46995,7 +47088,7 @@
46995	47088	state.addr = 819857494882385920LLU; // res_u64___
46996	47089	break;
46997	47090	}
46998		- case 18446744073709549553LLU: // 99999999dv'''''''''''''''
	47091	+ case 18446744073709549551LLU: // 99999999dt'''''''''''''''
46999	47092	{
47000	47093	// ACCUMULATE ARGUMENTS - BEGIN
47001	47094	{

		@@ -47003,7 +47096,7 @@
47003	47096	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47004	47097	}
47005	47098	// ACCUMULATE ARGUMENTS - END
47006		- uint64_t return_to = 18446744073709549552LLU;
	47099	+ uint64_t return_to = 18446744073709549550LLU;
47007	47100	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47008	47101	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47009	47102	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47012,7 +47105,7 @@
47012	47105	state.addr = 839519665163075584LLU; // skip______
47013	47106	break;
47014	47107	}
47015		- case 18446744073709549552LLU: // 99999999du'''''''''''''''
	47108	+ case 18446744073709549550LLU: // 99999999ds'''''''''''''''
47016	47109	{
47017	47110	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
47018	47111	fprintf(stdout, "%s", "\n ");

		@@ -47038,7 +47131,7 @@
47038	47131	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47039	47132	}
47040	47133	// ACCUMULATE ARGUMENTS - END
47041		- uint64_t return_to = 18446744073709549551LLU;
	47134	+ uint64_t return_to = 18446744073709549549LLU;
47042	47135	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
47043	47136	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47044	47137	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47047,7 +47140,7 @@
47047	47140	state.addr = 587881357514113024LLU; // emitpar___
47048	47141	break;
47049	47142	}
47050		- case 18446744073709549551LLU: // 99999999dt'''''''''''''''
	47143	+ case 18446744073709549549LLU: // 99999999dr'''''''''''''''
47051	47144	{
47052	47145	fprintf(stdout, "%s", " = parsenr(&");
47053	47146	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47056,7 +47149,7 @@
47056	47149	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47057	47150	}
47058	47151	// ACCUMULATE ARGUMENTS - END
47059		- uint64_t return_to = 18446744073709549550LLU;
	47152	+ uint64_t return_to = 18446744073709549548LLU;
47060	47153	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47061	47154	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47062	47155	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47065,7 +47158,7 @@
47065	47158	state.addr = 839519665163075584LLU; // skip______
47066	47159	break;
47067	47160	}
47068		- case 18446744073709549550LLU: // 99999999ds'''''''''''''''
	47161	+ case 18446744073709549548LLU: // 99999999dq'''''''''''''''
47069	47162	{
47070	47163
47071	47164	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -47087,7 +47180,7 @@
47087	47180	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47088	47181	}
47089	47182	// ACCUMULATE ARGUMENTS - END
47090		- uint64_t return_to = 18446744073709549549LLU;
	47183	+ uint64_t return_to = 18446744073709549547LLU;
47091	47184	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47092	47185	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47093	47186	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47096,7 +47189,7 @@
47096	47189	state.addr = 23446349213393492LLU; // ASSERTINIT
47097	47190	break;
47098	47191	}
47099		- case 18446744073709549549LLU: // 99999999dr'''''''''''''''
	47192	+ case 18446744073709549547LLU: // 99999999dp'''''''''''''''
47100	47193	{
47101	47194	{
47102	47195	uint64_t arg = 0;

		@@ -47175,7 +47268,7 @@
47175	47268	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47176	47269	}
47177	47270	// ACCUMULATE ARGUMENTS - END
47178		- uint64_t return_to = 18446744073709549548LLU;
	47271	+ uint64_t return_to = 18446744073709549546LLU;
47179	47272	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
47180	47273	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47181	47274	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47184,7 +47277,7 @@
47184	47277	state.addr = 293363126232490310LLU; // PROCVARREF
47185	47278	break;
47186	47279	}
47187		- case 18446744073709549548LLU: // 99999999dq'''''''''''''''
	47280	+ case 18446744073709549546LLU: // 99999999do'''''''''''''''
47188	47281	{
47189	47282	// variable u64 initialize goes out of scope
47190	47283	// emitted destructur for type u64

		@@ -47205,7 +47298,7 @@
47205	47298	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47206	47299	}
47207	47300	// ACCUMULATE ARGUMENTS - END
47208		- uint64_t return_to = 18446744073709549547LLU;
	47301	+ uint64_t return_to = 18446744073709549545LLU;
47209	47302	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
47210	47303	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47211	47304	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47214,7 +47307,7 @@
47214	47307	state.addr = 517555565476695680LLU; // assertu64_
47215	47308	break;
47216	47309	}
47217		- case 18446744073709549547LLU: // 99999999dp'''''''''''''''
	47310	+ case 18446744073709549545LLU: // 99999999dn'''''''''''''''
47218	47311	{
47219	47312	fprintf(stdout, "%s", ");");
47220	47313	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47223,7 +47316,7 @@
47223	47316	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47224	47317	}
47225	47318	// ACCUMULATE ARGUMENTS - END
47226		- uint64_t return_to = 18446744073709549546LLU;
	47319	+ uint64_t return_to = 18446744073709549544LLU;
47227	47320	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47228	47321	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47229	47322	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47232,7 +47325,7 @@
47232	47325	state.addr = 839519665163075584LLU; // skip______
47233	47326	break;
47234	47327	}
47235		- case 18446744073709549546LLU: // 99999999do'''''''''''''''
	47328	+ case 18446744073709549544LLU: // 99999999dm'''''''''''''''
47236	47329	{
47237	47330	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
47238	47331	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47245,7 +47338,7 @@
47245	47338	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47246	47339	}
47247	47340	// ACCUMULATE ARGUMENTS - END
47248		- uint64_t return_to = 18446744073709549545LLU;
	47341	+ uint64_t return_to = 18446744073709549543LLU;
47249	47342	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
47250	47343	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47251	47344	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47254,7 +47347,7 @@
47254	47347	state.addr = 517555565476695680LLU; // assertu64_
47255	47348	break;
47256	47349	}
47257		- case 18446744073709549545LLU: // 99999999dn'''''''''''''''
	47350	+ case 18446744073709549543LLU: // 99999999dl'''''''''''''''
47258	47351	{
47259	47352	{
47260	47353	uint64_t arg = 0;

		@@ -47283,7 +47376,7 @@
47283	47376	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47284	47377	}
47285	47378	// ACCUMULATE ARGUMENTS - END
47286		- uint64_t return_to = 18446744073709549544LLU;
	47379	+ uint64_t return_to = 18446744073709549542LLU;
47287	47380	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
47288	47381	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47289	47382	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47292,7 +47385,7 @@
47292	47385	state.addr = 734295421765213120LLU; // mutassert_
47293	47386	break;
47294	47387	}
47295		- case 18446744073709549544LLU: // 99999999dm'''''''''''''''
	47388	+ case 18446744073709549542LLU: // 99999999dk'''''''''''''''
47296	47389	{
47297	47390	// variable u64 parnr_____ goes out of scope
47298	47391	// emitted destructur for type u64

		@@ -47305,7 +47398,7 @@
47305	47398	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47306	47399	}
47307	47400	// ACCUMULATE ARGUMENTS - END
47308		- uint64_t return_to = 18446744073709549543LLU;
	47401	+ uint64_t return_to = 18446744073709549541LLU;
47309	47402	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47310	47403	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47311	47404	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47314,7 +47407,7 @@
47314	47407	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
47315	47408	break;
47316	47409	}
47317		- case 18446744073709549543LLU: // 99999999dl'''''''''''''''
	47410	+ case 18446744073709549541LLU: // 99999999dj'''''''''''''''
47318	47411	{
47319	47412	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
47320	47413	// variable type______ type______ goes out of scope

		@@ -47325,7 +47418,7 @@
47325	47418	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47326	47419	}
47327	47420	// ACCUMULATE ARGUMENTS - END
47328		- uint64_t return_to = 18446744073709549542LLU;
	47421	+ uint64_t return_to = 18446744073709549540LLU;
47329	47422	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47330	47423	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47331	47424	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47334,7 +47427,7 @@
47334	47427	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
47335	47428	break;
47336	47429	}
47337		- case 18446744073709549542LLU: // 99999999dk'''''''''''''''
	47430	+ case 18446744073709549540LLU: // 99999999di'''''''''''''''
47338	47431	{
47339	47432	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
47340	47433	// variable u64 mutable___ goes out of scope

		@@ -47346,10 +47439,10 @@
47346	47439	// variable u64 id________ goes out of scope
47347	47440	// emitted destructur for type u64
47348	47441	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
47349		- state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
	47442	+ state.addr = 18446744073709549555LLU; // 99999999dx'''''''''''''''
47350	47443	break;
47351	47444	}
47352		- case 18446744073709549558LLU: // 99999999d0'''''''''''''''
	47445	+ case 18446744073709549556LLU: // 99999999dy'''''''''''''''
47353	47446	{
47354	47447
47355	47448	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 750596285075554304;

		@@ -47360,11 +47453,11 @@
47360	47453	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
47361	47454	}
47362	47455	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47363		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549541LLU : 18446744073709549540LLU;
	47456	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549539LLU : 18446744073709549538LLU;
47364	47457	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
47365	47458	break;
47366	47459	}
47367		- case 18446744073709549541LLU: // 99999999dj'''''''''''''''
	47460	+ case 18446744073709549539LLU: // 99999999dh'''''''''''''''
47368	47461	{
47369	47462	{
47370	47463	uint64_t arg = 0;

		@@ -47391,7 +47484,7 @@
47391	47484	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47392	47485	}
47393	47486	// ACCUMULATE ARGUMENTS - END
47394		- uint64_t return_to = 18446744073709549538LLU;
	47487	+ uint64_t return_to = 18446744073709549536LLU;
47395	47488	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47396	47489	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47397	47490	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47400,7 +47493,7 @@
47400	47493	state.addr = 861504796319285248LLU; // typeu64___
47401	47494	break;
47402	47495	}
47403		- case 18446744073709549538LLU: // 99999999dg'''''''''''''''
	47496	+ case 18446744073709549536LLU: // 99999999de'''''''''''''''
47404	47497	{
47405	47498	{
47406	47499	uint64_t arg = 0;

		@@ -47425,7 +47518,7 @@
47425	47518	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47426	47519	}
47427	47520	// ACCUMULATE ARGUMENTS - END
47428		- uint64_t return_to = 18446744073709549536LLU;
	47521	+ uint64_t return_to = 18446744073709549534LLU;
47429	47522	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47430	47523	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47431	47524	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47434,7 +47527,7 @@
47434	47527	state.addr = 861504796319285248LLU; // typeu64___
47435	47528	break;
47436	47529	}
47437		- case 18446744073709549536LLU: // 99999999de'''''''''''''''
	47530	+ case 18446744073709549534LLU: // 99999999dc'''''''''''''''
47438	47531	{
47439	47532	{
47440	47533	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -47454,7 +47547,7 @@
47454	47547	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47455	47548	}
47456	47549	// ACCUMULATE ARGUMENTS - END
47457		- uint64_t return_to = 18446744073709549537LLU;
	47550	+ uint64_t return_to = 18446744073709549535LLU;
47458	47551	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47459	47552	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47460	47553	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47463,7 +47556,7 @@
47463	47556	state.addr = 819859607768530944LLU; // resdest___
47464	47557	break;
47465	47558	}
47466		- case 18446744073709549537LLU: // 99999999df'''''''''''''''
	47559	+ case 18446744073709549535LLU: // 99999999dd'''''''''''''''
47467	47560	{
47468	47561	// ACCUMULATE ARGUMENTS - BEGIN
47469	47562	{

		@@ -47483,7 +47576,7 @@
47483	47576	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47484	47577	}
47485	47578	// ACCUMULATE ARGUMENTS - END
47486		- uint64_t return_to = 18446744073709549535LLU;
	47579	+ uint64_t return_to = 18446744073709549533LLU;
47487	47580	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47488	47581	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47489	47582	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47492,7 +47585,7 @@
47492	47585	state.addr = 819857494882385920LLU; // res_u64___
47493	47586	break;
47494	47587	}
47495		- case 18446744073709549535LLU: // 99999999dd'''''''''''''''
	47588	+ case 18446744073709549533LLU: // 99999999db'''''''''''''''
47496	47589	{
47497	47590	// ACCUMULATE ARGUMENTS - BEGIN
47498	47591	{

		@@ -47500,7 +47593,7 @@
47500	47593	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47501	47594	}
47502	47595	// ACCUMULATE ARGUMENTS - END
47503		- uint64_t return_to = 18446744073709549534LLU;
	47596	+ uint64_t return_to = 18446744073709549532LLU;
47504	47597	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47505	47598	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47506	47599	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47509,7 +47602,7 @@
47509	47602	state.addr = 839519665163075584LLU; // skip______
47510	47603	break;
47511	47604	}
47512		- case 18446744073709549534LLU: // 99999999dc'''''''''''''''
	47605	+ case 18446744073709549532LLU: // 99999999da'''''''''''''''
47513	47606	{
47514	47607	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
47515	47608	fprintf(stdout, "%s", "\n ");

		@@ -47535,7 +47628,7 @@
47535	47628	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47536	47629	}
47537	47630	// ACCUMULATE ARGUMENTS - END
47538		- uint64_t return_to = 18446744073709549533LLU;
	47631	+ uint64_t return_to = 18446744073709549531LLU;
47539	47632	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
47540	47633	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47541	47634	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47544,7 +47637,7 @@
47544	47637	state.addr = 587881357514113024LLU; // emitpar___
47545	47638	break;
47546	47639	}
47547		- case 18446744073709549533LLU: // 99999999db'''''''''''''''
	47640	+ case 18446744073709549531LLU: // 99999999d$'''''''''''''''
47548	47641	{
47549	47642	fprintf(stdout, "%s", " = !!");
47550	47643	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47553,7 +47646,7 @@
47553	47646	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47554	47647	}
47555	47648	// ACCUMULATE ARGUMENTS - END
47556		- uint64_t return_to = 18446744073709549532LLU;
	47649	+ uint64_t return_to = 18446744073709549530LLU;
47557	47650	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47558	47651	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47559	47652	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47562,7 +47655,7 @@
47562	47655	state.addr = 839519665163075584LLU; // skip______
47563	47656	break;
47564	47657	}
47565		- case 18446744073709549532LLU: // 99999999da'''''''''''''''
	47658	+ case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
47566	47659	{
47567	47660
47568	47661	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -47584,7 +47677,7 @@
47584	47677	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47585	47678	}
47586	47679	// ACCUMULATE ARGUMENTS - END
47587		- uint64_t return_to = 18446744073709549531LLU;
	47680	+ uint64_t return_to = 18446744073709549529LLU;
47588	47681	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47589	47682	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47590	47683	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47593,7 +47686,7 @@
47593	47686	state.addr = 23446349213393492LLU; // ASSERTINIT
47594	47687	break;
47595	47688	}
47596		- case 18446744073709549531LLU: // 99999999d$'''''''''''''''
	47689	+ case 18446744073709549529LLU: // 99999999dY'''''''''''''''
47597	47690	{
47598	47691	{
47599	47692	uint64_t arg = 0;

		@@ -47672,7 +47765,7 @@
47672	47765	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47673	47766	}
47674	47767	// ACCUMULATE ARGUMENTS - END
47675		- uint64_t return_to = 18446744073709549530LLU;
	47768	+ uint64_t return_to = 18446744073709549528LLU;
47676	47769	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
47677	47770	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47678	47771	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47681,7 +47774,7 @@
47681	47774	state.addr = 293363126232490310LLU; // PROCVARREF
47682	47775	break;
47683	47776	}
47684		- case 18446744073709549530LLU: // 99999999dZ'''''''''''''''
	47777	+ case 18446744073709549528LLU: // 99999999dX'''''''''''''''
47685	47778	{
47686	47779	// variable u64 initialize goes out of scope
47687	47780	// emitted destructur for type u64

		@@ -47698,7 +47791,7 @@
47698	47791	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47699	47792	}
47700	47793	// ACCUMULATE ARGUMENTS - END
47701		- uint64_t return_to = 18446744073709549529LLU;
	47794	+ uint64_t return_to = 18446744073709549527LLU;
47702	47795	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47703	47796	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47704	47797	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47707,7 +47800,7 @@
47707	47800	state.addr = 839519665163075584LLU; // skip______
47708	47801	break;
47709	47802	}
47710		- case 18446744073709549529LLU: // 99999999dY'''''''''''''''
	47803	+ case 18446744073709549527LLU: // 99999999dW'''''''''''''''
47711	47804	{
47712	47805	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
47713	47806	fprintf(stdout, "%s", ";");

		@@ -47719,7 +47812,7 @@
47719	47812	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47720	47813	}
47721	47814	// ACCUMULATE ARGUMENTS - END
47722		- uint64_t return_to = 18446744073709549528LLU;
	47815	+ uint64_t return_to = 18446744073709549526LLU;
47723	47816	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47724	47817	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47725	47818	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47728,7 +47821,7 @@
47728	47821	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
47729	47822	break;
47730	47823	}
47731		- case 18446744073709549528LLU: // 99999999dX'''''''''''''''
	47824	+ case 18446744073709549526LLU: // 99999999dV'''''''''''''''
47732	47825	{
47733	47826	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
47734	47827	// variable type______ type______ goes out of scope

		@@ -47739,7 +47832,7 @@
47739	47832	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47740	47833	}
47741	47834	// ACCUMULATE ARGUMENTS - END
47742		- uint64_t return_to = 18446744073709549527LLU;
	47835	+ uint64_t return_to = 18446744073709549525LLU;
47743	47836	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47744	47837	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47745	47838	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47748,7 +47841,7 @@
47748	47841	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
47749	47842	break;
47750	47843	}
47751		- case 18446744073709549527LLU: // 99999999dW'''''''''''''''
	47844	+ case 18446744073709549525LLU: // 99999999dU'''''''''''''''
47752	47845	{
47753	47846	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
47754	47847	// variable u64 mutable___ goes out of scope

		@@ -47760,10 +47853,10 @@
47760	47853	// variable u64 id________ goes out of scope
47761	47854	// emitted destructur for type u64
47762	47855	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
47763		- state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
	47856	+ state.addr = 18446744073709549537LLU; // 99999999df'''''''''''''''
47764	47857	break;
47765	47858	}
47766		- case 18446744073709549540LLU: // 99999999di'''''''''''''''
	47859	+ case 18446744073709549538LLU: // 99999999dg'''''''''''''''
47767	47860	{
47768	47861
47769	47862	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 839030726086098944;

		@@ -47774,11 +47867,11 @@
47774	47867	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
47775	47868	}
47776	47869	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
47777		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549526LLU : 18446744073709549525LLU;
	47870	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549524LLU : 18446744073709549523LLU;
47778	47871	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
47779	47872	break;
47780	47873	}
47781		- case 18446744073709549526LLU: // 99999999dV'''''''''''''''
	47874	+ case 18446744073709549524LLU: // 99999999dT'''''''''''''''
47782	47875	{
47783	47876	{
47784	47877	uint64_t arg = 0;

		@@ -47803,7 +47896,7 @@
47803	47896	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47804	47897	}
47805	47898	// ACCUMULATE ARGUMENTS - END
47806		- uint64_t return_to = 18446744073709549522LLU;
	47899	+ uint64_t return_to = 18446744073709549520LLU;
47807	47900	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47808	47901	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47809	47902	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47812,7 +47905,7 @@
47812	47905	state.addr = 861504796319285248LLU; // typeu64___
47813	47906	break;
47814	47907	}
47815		- case 18446744073709549522LLU: // 99999999dR'''''''''''''''
	47908	+ case 18446744073709549520LLU: // 99999999dP'''''''''''''''
47816	47909	{
47817	47910	{
47818	47911	uint64_t exchange = LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 19*/;

		@@ -47832,7 +47925,7 @@
47832	47925	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47833	47926	}
47834	47927	// ACCUMULATE ARGUMENTS - END
47835		- uint64_t return_to = 18446744073709549523LLU;
	47928	+ uint64_t return_to = 18446744073709549521LLU;
47836	47929	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47837	47930	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47838	47931	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47841,7 +47934,7 @@
47841	47934	state.addr = 819859607768530944LLU; // resdest___
47842	47935	break;
47843	47936	}
47844		- case 18446744073709549523LLU: // 99999999dS'''''''''''''''
	47937	+ case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
47845	47938	{
47846	47939	// ACCUMULATE ARGUMENTS - BEGIN
47847	47940	{

		@@ -47861,7 +47954,7 @@
47861	47954	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47862	47955	}
47863	47956	// ACCUMULATE ARGUMENTS - END
47864		- uint64_t return_to = 18446744073709549521LLU;
	47957	+ uint64_t return_to = 18446744073709549519LLU;
47865	47958	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
47866	47959	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47867	47960	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47870,7 +47963,7 @@
47870	47963	state.addr = 819857494882385920LLU; // res_u64___
47871	47964	break;
47872	47965	}
47873		- case 18446744073709549521LLU: // 99999999dQ'''''''''''''''
	47966	+ case 18446744073709549519LLU: // 99999999dO'''''''''''''''
47874	47967	{
47875	47968	// ACCUMULATE ARGUMENTS - BEGIN
47876	47969	{

		@@ -47878,7 +47971,7 @@
47878	47971	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47879	47972	}
47880	47973	// ACCUMULATE ARGUMENTS - END
47881		- uint64_t return_to = 18446744073709549520LLU;
	47974	+ uint64_t return_to = 18446744073709549518LLU;
47882	47975	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47883	47976	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47884	47977	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47887,7 +47980,7 @@
47887	47980	state.addr = 839519665163075584LLU; // skip______
47888	47981	break;
47889	47982	}
47890		- case 18446744073709549520LLU: // 99999999dP'''''''''''''''
	47983	+ case 18446744073709549518LLU: // 99999999dN'''''''''''''''
47891	47984	{
47892	47985	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
47893	47986	fprintf(stdout, "%s", "\n list_size(heap.data, &");

		@@ -47913,7 +48006,7 @@
47913	48006	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47914	48007	}
47915	48008	// ACCUMULATE ARGUMENTS - END
47916		- uint64_t return_to = 18446744073709549519LLU;
	48009	+ uint64_t return_to = 18446744073709549517LLU;
47917	48010	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
47918	48011	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47919	48012	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47922,7 +48015,7 @@
47922	48015	state.addr = 587881357514113024LLU; // emitpar___
47923	48016	break;
47924	48017	}
47925		- case 18446744073709549519LLU: // 99999999dO'''''''''''''''
	48018	+ case 18446744073709549517LLU: // 99999999dM'''''''''''''''
47926	48019	{
47927	48020	fprintf(stdout, "%s", ", ");
47928	48021	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -47931,7 +48024,7 @@
47931	48024	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47932	48025	}
47933	48026	// ACCUMULATE ARGUMENTS - END
47934		- uint64_t return_to = 18446744073709549518LLU;
	48027	+ uint64_t return_to = 18446744073709549516LLU;
47935	48028	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47936	48029	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47937	48030	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47940,7 +48033,7 @@
47940	48033	state.addr = 839519665163075584LLU; // skip______
47941	48034	break;
47942	48035	}
47943		- case 18446744073709549518LLU: // 99999999dN'''''''''''''''
	48036	+ case 18446744073709549516LLU: // 99999999dL'''''''''''''''
47944	48037	{
47945	48038	{
47946	48039	uint64_t arg = 0;

		@@ -47952,7 +48045,7 @@
47952	48045	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
47953	48046	}
47954	48047	// ACCUMULATE ARGUMENTS - END
47955		- uint64_t return_to = 18446744073709549517LLU;
	48048	+ uint64_t return_to = 18446744073709549515LLU;
47956	48049	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
47957	48050	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
47958	48051	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -47961,7 +48054,7 @@
47961	48054	state.addr = 861504796319285248LLU; // typeu64___
47962	48055	break;
47963	48056	}
47964		- case 18446744073709549517LLU: // 99999999dM'''''''''''''''
	48057	+ case 18446744073709549515LLU: // 99999999dK'''''''''''''''
47965	48058	{
47966	48059	{
47967	48060	uint64_t arg = 0;

		@@ -48055,7 +48148,7 @@
48055	48148	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48056	48149	}
48057	48150	// ACCUMULATE ARGUMENTS - END
48058		- uint64_t return_to = 18446744073709549516LLU;
	48151	+ uint64_t return_to = 18446744073709549514LLU;
48059	48152	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
48060	48153	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48061	48154	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48064,7 +48157,7 @@
48064	48157	state.addr = 293363126232490310LLU; // PROCVARREF
48065	48158	break;
48066	48159	}
48067		- case 18446744073709549516LLU: // 99999999dL'''''''''''''''
	48160	+ case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
48068	48161	{
48069	48162	// ACCUMULATE ARGUMENTS - BEGIN
48070	48163	{

		@@ -48076,7 +48169,7 @@
48076	48169	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48077	48170	}
48078	48171	// ACCUMULATE ARGUMENTS - END
48079		- uint64_t return_to = 18446744073709549515LLU;
	48172	+ uint64_t return_to = 18446744073709549513LLU;
48080	48173	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
48081	48174	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48082	48175	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48085,7 +48178,7 @@
48085	48178	state.addr = 517555565474237359LLU; // assertlist
48086	48179	break;
48087	48180	}
48088		- case 18446744073709549515LLU: // 99999999dK'''''''''''''''
	48181	+ case 18446744073709549513LLU: // 99999999dI'''''''''''''''
48089	48182	{
48090	48183	// variable u64 mutable0__ goes out of scope
48091	48184	// emitted destructur for type u64

		@@ -48113,7 +48206,7 @@
48113	48206	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48114	48207	}
48115	48208	// ACCUMULATE ARGUMENTS - END
48116		- uint64_t return_to = 18446744073709549514LLU;
	48209	+ uint64_t return_to = 18446744073709549512LLU;
48117	48210	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48118	48211	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48119	48212	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48122,7 +48215,7 @@
48122	48215	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
48123	48216	break;
48124	48217	}
48125		- case 18446744073709549514LLU: // 99999999dJ'''''''''''''''
	48218	+ case 18446744073709549512LLU: // 99999999dH'''''''''''''''
48126	48219	{
48127	48220	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type0_____ at 18
48128	48221	fprintf(stdout, "%s", ");");

		@@ -48132,7 +48225,7 @@
48132	48225	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48133	48226	}
48134	48227	// ACCUMULATE ARGUMENTS - END
48135		- uint64_t return_to = 18446744073709549513LLU;
	48228	+ uint64_t return_to = 18446744073709549511LLU;
48136	48229	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48137	48230	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48138	48231	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48141,7 +48234,7 @@
48141	48234	state.addr = 839519665163075584LLU; // skip______
48142	48235	break;
48143	48236	}
48144		- case 18446744073709549513LLU: // 99999999dI'''''''''''''''
	48237	+ case 18446744073709549511LLU: // 99999999dG'''''''''''''''
48145	48238	{
48146	48239	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 7LLU)));
48147	48240	// variable resdest___ single____ goes out of scope

		@@ -48152,7 +48245,7 @@
48152	48245	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48153	48246	}
48154	48247	// ACCUMULATE ARGUMENTS - END
48155		- uint64_t return_to = 18446744073709549512LLU;
	48248	+ uint64_t return_to = 18446744073709549510LLU;
48156	48249	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48157	48250	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48158	48251	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48161,43 +48254,43 @@
48161	48254	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
48162	48255	break;
48163	48256	}
48164		- case 18446744073709549512LLU: // 99999999dH'''''''''''''''
	48257	+ case 18446744073709549510LLU: // 99999999dF'''''''''''''''
48165	48258	{
48166	48259	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 17
48167		- state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
	48260	+ state.addr = 18446744073709549522LLU; // 99999999dR'''''''''''''''
48168	48261	break;
48169	48262	}
48170		- case 18446744073709549525LLU: // 99999999dU'''''''''''''''
	48263	+ case 18446744073709549523LLU: // 99999999dS'''''''''''''''
48171	48264	{
48172		- state.addr = 18446744073709549524LLU; // 99999999dT'''''''''''''''
	48265	+ state.addr = 18446744073709549522LLU; // 99999999dR'''''''''''''''
48173	48266	break;
48174	48267	}
48175		- case 18446744073709549524LLU: // 99999999dT'''''''''''''''
	48268	+ case 18446744073709549522LLU: // 99999999dR'''''''''''''''
48176	48269	{
48177		- state.addr = 18446744073709549539LLU; // 99999999dh'''''''''''''''
	48270	+ state.addr = 18446744073709549537LLU; // 99999999df'''''''''''''''
48178	48271	break;
48179	48272	}
48180		- case 18446744073709549539LLU: // 99999999dh'''''''''''''''
	48273	+ case 18446744073709549537LLU: // 99999999df'''''''''''''''
48181	48274	{
48182		- state.addr = 18446744073709549557LLU; // 99999999dz'''''''''''''''
	48275	+ state.addr = 18446744073709549555LLU; // 99999999dx'''''''''''''''
48183	48276	break;
48184	48277	}
48185		- case 18446744073709549557LLU: // 99999999dz'''''''''''''''
	48278	+ case 18446744073709549555LLU: // 99999999dx'''''''''''''''
48186	48279	{
48187		- state.addr = 18446744073709549575LLU; // 99999999eG'''''''''''''''
	48280	+ state.addr = 18446744073709549573LLU; // 99999999eE'''''''''''''''
48188	48281	break;
48189	48282	}
48190		- case 18446744073709549575LLU: // 99999999eG'''''''''''''''
	48283	+ case 18446744073709549573LLU: // 99999999eE'''''''''''''''
48191	48284	{
48192		- state.addr = 18446744073709549591LLU; // 99999999eW'''''''''''''''
	48285	+ state.addr = 18446744073709549589LLU; // 99999999eU'''''''''''''''
48193	48286	break;
48194	48287	}
48195		- case 18446744073709549591LLU: // 99999999eW'''''''''''''''
	48288	+ case 18446744073709549589LLU: // 99999999eU'''''''''''''''
48196	48289	{
48197		- state.addr = 18446744073709549607LLU; // 99999999el'''''''''''''''
	48290	+ state.addr = 18446744073709549605LLU; // 99999999ej'''''''''''''''
48198	48291	break;
48199	48292	}
48200		- case 18446744073709549607LLU: // 99999999el'''''''''''''''
	48293	+ case 18446744073709549605LLU: // 99999999ej'''''''''''''''
48201	48294	{
48202	48295	// variable u64 sym_______ goes out of scope
48203	48296	// emitted destructur for type u64

		@@ -48256,11 +48349,11 @@
48256	48349	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
48257	48350	}
48258	48351	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48259		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549511LLU : 18446744073709549510LLU;
	48352	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549509LLU : 18446744073709549508LLU;
48260	48353	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
48261	48354	break;
48262	48355	}
48263		- case 18446744073709549511LLU: // 99999999dG'''''''''''''''
	48356	+ case 18446744073709549509LLU: // 99999999dE'''''''''''''''
48264	48357	{
48265	48358	{
48266	48359	uint64_t arg = 0;

		@@ -48287,7 +48380,7 @@
48287	48380	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48288	48381	}
48289	48382	// ACCUMULATE ARGUMENTS - END
48290		- uint64_t return_to = 18446744073709549508LLU;
	48383	+ uint64_t return_to = 18446744073709549506LLU;
48291	48384	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48292	48385	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48293	48386	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48296,7 +48389,7 @@
48296	48389	state.addr = 861504796319285248LLU; // typeu64___
48297	48390	break;
48298	48391	}
48299		- case 18446744073709549508LLU: // 99999999dD'''''''''''''''
	48392	+ case 18446744073709549506LLU: // 99999999dB'''''''''''''''
48300	48393	{
48301	48394	{
48302	48395	uint64_t arg = 0;

		@@ -48321,7 +48414,7 @@
48321	48414	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48322	48415	}
48323	48416	// ACCUMULATE ARGUMENTS - END
48324		- uint64_t return_to = 18446744073709549506LLU;
	48417	+ uint64_t return_to = 18446744073709549504LLU;
48325	48418	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48326	48419	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48327	48420	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48330,7 +48423,7 @@
48330	48423	state.addr = 861504796319285248LLU; // typeu64___
48331	48424	break;
48332	48425	}
48333		- case 18446744073709549506LLU: // 99999999dB'''''''''''''''
	48426	+ case 18446744073709549504LLU: // 99999999d_'''''''''''''''
48334	48427	{
48335	48428	{
48336	48429	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -48350,7 +48443,7 @@
48350	48443	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48351	48444	}
48352	48445	// ACCUMULATE ARGUMENTS - END
48353		- uint64_t return_to = 18446744073709549507LLU;
	48446	+ uint64_t return_to = 18446744073709549505LLU;
48354	48447	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48355	48448	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48356	48449	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48359,7 +48452,7 @@
48359	48452	state.addr = 819859607768530944LLU; // resdest___
48360	48453	break;
48361	48454	}
48362		- case 18446744073709549507LLU: // 99999999dC'''''''''''''''
	48455	+ case 18446744073709549505LLU: // 99999999dA'''''''''''''''
48363	48456	{
48364	48457	// ACCUMULATE ARGUMENTS - BEGIN
48365	48458	{

		@@ -48379,7 +48472,7 @@
48379	48472	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48380	48473	}
48381	48474	// ACCUMULATE ARGUMENTS - END
48382		- uint64_t return_to = 18446744073709549505LLU;
	48475	+ uint64_t return_to = 18446744073709549503LLU;
48383	48476	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48384	48477	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48385	48478	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48388,7 +48481,7 @@
48388	48481	state.addr = 819857494882385920LLU; // res_u64___
48389	48482	break;
48390	48483	}
48391		- case 18446744073709549505LLU: // 99999999dA'''''''''''''''
	48484	+ case 18446744073709549503LLU: // 99999999c9'''''''''''''''
48392	48485	{
48393	48486	// ACCUMULATE ARGUMENTS - BEGIN
48394	48487	{

		@@ -48396,7 +48489,7 @@
48396	48489	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48397	48490	}
48398	48491	// ACCUMULATE ARGUMENTS - END
48399		- uint64_t return_to = 18446744073709549504LLU;
	48492	+ uint64_t return_to = 18446744073709549502LLU;
48400	48493	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48401	48494	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48402	48495	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48405,7 +48498,7 @@
48405	48498	state.addr = 839519665163075584LLU; // skip______
48406	48499	break;
48407	48500	}
48408		- case 18446744073709549504LLU: // 99999999d_'''''''''''''''
	48501	+ case 18446744073709549502LLU: // 99999999c8'''''''''''''''
48409	48502	{
48410	48503	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
48411	48504	fprintf(stdout, "%s", "\n ");

		@@ -48431,7 +48524,7 @@
48431	48524	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48432	48525	}
48433	48526	// ACCUMULATE ARGUMENTS - END
48434		- uint64_t return_to = 18446744073709549503LLU;
	48527	+ uint64_t return_to = 18446744073709549501LLU;
48435	48528	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
48436	48529	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48437	48530	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48440,7 +48533,7 @@
48440	48533	state.addr = 587881357514113024LLU; // emitpar___
48441	48534	break;
48442	48535	}
48443		- case 18446744073709549503LLU: // 99999999c9'''''''''''''''
	48536	+ case 18446744073709549501LLU: // 99999999c7'''''''''''''''
48444	48537	{
48445	48538	fprintf(stdout, "%s", " = ");
48446	48539	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -48449,7 +48542,7 @@
48449	48542	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48450	48543	}
48451	48544	// ACCUMULATE ARGUMENTS - END
48452		- uint64_t return_to = 18446744073709549502LLU;
	48545	+ uint64_t return_to = 18446744073709549500LLU;
48453	48546	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48454	48547	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48455	48548	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48458,7 +48551,7 @@
48458	48551	state.addr = 839519665163075584LLU; // skip______
48459	48552	break;
48460	48553	}
48461		- case 18446744073709549502LLU: // 99999999c8'''''''''''''''
	48554	+ case 18446744073709549500LLU: // 99999999c6'''''''''''''''
48462	48555	{
48463	48556
48464	48557	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -48480,7 +48573,7 @@
48480	48573	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48481	48574	}
48482	48575	// ACCUMULATE ARGUMENTS - END
48483		- uint64_t return_to = 18446744073709549501LLU;
	48576	+ uint64_t return_to = 18446744073709549499LLU;
48484	48577	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48485	48578	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48486	48579	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48489,7 +48582,7 @@
48489	48582	state.addr = 23446349213393492LLU; // ASSERTINIT
48490	48583	break;
48491	48584	}
48492		- case 18446744073709549501LLU: // 99999999c7'''''''''''''''
	48585	+ case 18446744073709549499LLU: // 99999999c5'''''''''''''''
48493	48586	{
48494	48587	{
48495	48588	uint64_t arg = 0;

		@@ -48568,7 +48661,7 @@
48568	48661	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48569	48662	}
48570	48663	// ACCUMULATE ARGUMENTS - END
48571		- uint64_t return_to = 18446744073709549500LLU;
	48664	+ uint64_t return_to = 18446744073709549498LLU;
48572	48665	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
48573	48666	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48574	48667	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48577,7 +48670,7 @@
48577	48670	state.addr = 293363126232490310LLU; // PROCVARREF
48578	48671	break;
48579	48672	}
48580		- case 18446744073709549500LLU: // 99999999c6'''''''''''''''
	48673	+ case 18446744073709549498LLU: // 99999999c4'''''''''''''''
48581	48674	{
48582	48675	// variable u64 initialize goes out of scope
48583	48676	// emitted destructur for type u64

		@@ -48598,7 +48691,7 @@
48598	48691	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48599	48692	}
48600	48693	// ACCUMULATE ARGUMENTS - END
48601		- uint64_t return_to = 18446744073709549499LLU;
	48694	+ uint64_t return_to = 18446744073709549497LLU;
48602	48695	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
48603	48696	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48604	48697	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48607,7 +48700,7 @@
48607	48700	state.addr = 517555565476695680LLU; // assertu64_
48608	48701	break;
48609	48702	}
48610		- case 18446744073709549499LLU: // 99999999c5'''''''''''''''
	48703	+ case 18446744073709549497LLU: // 99999999c3'''''''''''''''
48611	48704	{
48612	48705	// ACCUMULATE ARGUMENTS - BEGIN
48613	48706	{

		@@ -48615,7 +48708,7 @@
48615	48708	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48616	48709	}
48617	48710	// ACCUMULATE ARGUMENTS - END
48618		- uint64_t return_to = 18446744073709549498LLU;
	48711	+ uint64_t return_to = 18446744073709549496LLU;
48619	48712	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48620	48713	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48621	48714	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48624,7 +48717,7 @@
48624	48717	state.addr = 839519665163075584LLU; // skip______
48625	48718	break;
48626	48719	}
48627		- case 18446744073709549498LLU: // 99999999c4'''''''''''''''
	48720	+ case 18446744073709549496LLU: // 99999999c2'''''''''''''''
48628	48721	{
48629	48722	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
48630	48723	fprintf(stdout, "%s", " & ");

		@@ -48634,7 +48727,7 @@
48634	48727	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48635	48728	}
48636	48729	// ACCUMULATE ARGUMENTS - END
48637		- uint64_t return_to = 18446744073709549497LLU;
	48730	+ uint64_t return_to = 18446744073709549495LLU;
48638	48731	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48639	48732	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48640	48733	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48643,7 +48736,7 @@
48643	48736	state.addr = 839519665163075584LLU; // skip______
48644	48737	break;
48645	48738	}
48646		- case 18446744073709549497LLU: // 99999999c3'''''''''''''''
	48739	+ case 18446744073709549495LLU: // 99999999c1'''''''''''''''
48647	48740	{
48648	48741
48649	48742	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -48665,7 +48758,7 @@
48665	48758	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48666	48759	}
48667	48760	// ACCUMULATE ARGUMENTS - END
48668		- uint64_t return_to = 18446744073709549496LLU;
	48761	+ uint64_t return_to = 18446744073709549494LLU;
48669	48762	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48670	48763	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48671	48764	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48674,7 +48767,7 @@
48674	48767	state.addr = 23446349213393492LLU; // ASSERTINIT
48675	48768	break;
48676	48769	}
48677		- case 18446744073709549496LLU: // 99999999c2'''''''''''''''
	48770	+ case 18446744073709549494LLU: // 99999999c0'''''''''''''''
48678	48771	{
48679	48772	{
48680	48773	uint64_t arg = 0;

		@@ -48753,7 +48846,7 @@
48753	48846	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48754	48847	}
48755	48848	// ACCUMULATE ARGUMENTS - END
48756		- uint64_t return_to = 18446744073709549495LLU;
	48849	+ uint64_t return_to = 18446744073709549493LLU;
48757	48850	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
48758	48851	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48759	48852	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48762,7 +48855,7 @@
48762	48855	state.addr = 293363126232490310LLU; // PROCVARREF
48763	48856	break;
48764	48857	}
48765		- case 18446744073709549495LLU: // 99999999c1'''''''''''''''
	48858	+ case 18446744073709549493LLU: // 99999999cz'''''''''''''''
48766	48859	{
48767	48860	// variable u64 initialize goes out of scope
48768	48861	// emitted destructur for type u64

		@@ -48783,7 +48876,7 @@
48783	48876	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48784	48877	}
48785	48878	// ACCUMULATE ARGUMENTS - END
48786		- uint64_t return_to = 18446744073709549494LLU;
	48879	+ uint64_t return_to = 18446744073709549492LLU;
48787	48880	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
48788	48881	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48789	48882	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48792,7 +48885,7 @@
48792	48885	state.addr = 517555565476695680LLU; // assertu64_
48793	48886	break;
48794	48887	}
48795		- case 18446744073709549494LLU: // 99999999c0'''''''''''''''
	48888	+ case 18446744073709549492LLU: // 99999999cy'''''''''''''''
48796	48889	{
48797	48890	// ACCUMULATE ARGUMENTS - BEGIN
48798	48891	{

		@@ -48800,7 +48893,7 @@
48800	48893	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48801	48894	}
48802	48895	// ACCUMULATE ARGUMENTS - END
48803		- uint64_t return_to = 18446744073709549493LLU;
	48896	+ uint64_t return_to = 18446744073709549491LLU;
48804	48897	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48805	48898	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48806	48899	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48809,7 +48902,7 @@
48809	48902	state.addr = 839519665163075584LLU; // skip______
48810	48903	break;
48811	48904	}
48812		- case 18446744073709549493LLU: // 99999999cz'''''''''''''''
	48905	+ case 18446744073709549491LLU: // 99999999cx'''''''''''''''
48813	48906	{
48814	48907	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
48815	48908	fprintf(stdout, "%s", ";");

		@@ -48821,7 +48914,7 @@
48821	48914	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48822	48915	}
48823	48916	// ACCUMULATE ARGUMENTS - END
48824		- uint64_t return_to = 18446744073709549492LLU;
	48917	+ uint64_t return_to = 18446744073709549490LLU;
48825	48918	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48826	48919	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48827	48920	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48830,7 +48923,7 @@
48830	48923	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
48831	48924	break;
48832	48925	}
48833		- case 18446744073709549492LLU: // 99999999cy'''''''''''''''
	48926	+ case 18446744073709549490LLU: // 99999999cw'''''''''''''''
48834	48927	{
48835	48928	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
48836	48929	// variable type______ type______ goes out of scope

		@@ -48841,7 +48934,7 @@
48841	48934	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48842	48935	}
48843	48936	// ACCUMULATE ARGUMENTS - END
48844		- uint64_t return_to = 18446744073709549491LLU;
	48937	+ uint64_t return_to = 18446744073709549489LLU;
48845	48938	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48846	48939	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48847	48940	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48850,7 +48943,7 @@
48850	48943	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
48851	48944	break;
48852	48945	}
48853		- case 18446744073709549491LLU: // 99999999cx'''''''''''''''
	48946	+ case 18446744073709549489LLU: // 99999999cv'''''''''''''''
48854	48947	{
48855	48948	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
48856	48949	// variable u64 mutable___ goes out of scope

		@@ -48862,10 +48955,10 @@
48862	48955	// variable u64 id________ goes out of scope
48863	48956	// emitted destructur for type u64
48864	48957	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
48865		- state.addr = 18446744073709549509LLU; // 99999999dE'''''''''''''''
	48958	+ state.addr = 18446744073709549507LLU; // 99999999dC'''''''''''''''
48866	48959	break;
48867	48960	}
48868		- case 18446744073709549510LLU: // 99999999dF'''''''''''''''
	48961	+ case 18446744073709549508LLU: // 99999999dD'''''''''''''''
48869	48962	{
48870	48963
48871	48964	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 532757409974714368;

		@@ -48876,11 +48969,11 @@
48876	48969	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
48877	48970	}
48878	48971	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
48879		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549490LLU : 18446744073709549489LLU;
	48972	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549488LLU : 18446744073709549487LLU;
48880	48973	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
48881	48974	break;
48882	48975	}
48883		- case 18446744073709549490LLU: // 99999999cw'''''''''''''''
	48976	+ case 18446744073709549488LLU: // 99999999cu'''''''''''''''
48884	48977	{
48885	48978	{
48886	48979	uint64_t arg = 0;

		@@ -48907,7 +49000,7 @@
48907	49000	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48908	49001	}
48909	49002	// ACCUMULATE ARGUMENTS - END
48910		- uint64_t return_to = 18446744073709549487LLU;
	49003	+ uint64_t return_to = 18446744073709549485LLU;
48911	49004	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48912	49005	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48913	49006	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48916,7 +49009,7 @@
48916	49009	state.addr = 861504796319285248LLU; // typeu64___
48917	49010	break;
48918	49011	}
48919		- case 18446744073709549487LLU: // 99999999ct'''''''''''''''
	49012	+ case 18446744073709549485LLU: // 99999999cr'''''''''''''''
48920	49013	{
48921	49014	{
48922	49015	uint64_t arg = 0;

		@@ -48941,7 +49034,7 @@
48941	49034	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48942	49035	}
48943	49036	// ACCUMULATE ARGUMENTS - END
48944		- uint64_t return_to = 18446744073709549485LLU;
	49037	+ uint64_t return_to = 18446744073709549483LLU;
48945	49038	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
48946	49039	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48947	49040	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48950,7 +49043,7 @@
48950	49043	state.addr = 861504796319285248LLU; // typeu64___
48951	49044	break;
48952	49045	}
48953		- case 18446744073709549485LLU: // 99999999cr'''''''''''''''
	49046	+ case 18446744073709549483LLU: // 99999999cp'''''''''''''''
48954	49047	{
48955	49048	{
48956	49049	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -48970,7 +49063,7 @@
48970	49063	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
48971	49064	}
48972	49065	// ACCUMULATE ARGUMENTS - END
48973		- uint64_t return_to = 18446744073709549486LLU;
	49066	+ uint64_t return_to = 18446744073709549484LLU;
48974	49067	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
48975	49068	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
48976	49069	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -48979,7 +49072,7 @@
48979	49072	state.addr = 819859607768530944LLU; // resdest___
48980	49073	break;
48981	49074	}
48982		- case 18446744073709549486LLU: // 99999999cs'''''''''''''''
	49075	+ case 18446744073709549484LLU: // 99999999cq'''''''''''''''
48983	49076	{
48984	49077	// ACCUMULATE ARGUMENTS - BEGIN
48985	49078	{

		@@ -48999,7 +49092,7 @@
48999	49092	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49000	49093	}
49001	49094	// ACCUMULATE ARGUMENTS - END
49002		- uint64_t return_to = 18446744073709549484LLU;
	49095	+ uint64_t return_to = 18446744073709549482LLU;
49003	49096	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49004	49097	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49005	49098	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49008,7 +49101,7 @@
49008	49101	state.addr = 819857494882385920LLU; // res_u64___
49009	49102	break;
49010	49103	}
49011		- case 18446744073709549484LLU: // 99999999cq'''''''''''''''
	49104	+ case 18446744073709549482LLU: // 99999999co'''''''''''''''
49012	49105	{
49013	49106	// ACCUMULATE ARGUMENTS - BEGIN
49014	49107	{

		@@ -49016,7 +49109,7 @@
49016	49109	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49017	49110	}
49018	49111	// ACCUMULATE ARGUMENTS - END
49019		- uint64_t return_to = 18446744073709549483LLU;
	49112	+ uint64_t return_to = 18446744073709549481LLU;
49020	49113	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49021	49114	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49022	49115	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49025,7 +49118,7 @@
49025	49118	state.addr = 839519665163075584LLU; // skip______
49026	49119	break;
49027	49120	}
49028		- case 18446744073709549483LLU: // 99999999cp'''''''''''''''
	49121	+ case 18446744073709549481LLU: // 99999999cn'''''''''''''''
49029	49122	{
49030	49123	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
49031	49124	fprintf(stdout, "%s", "\n ");

		@@ -49051,7 +49144,7 @@
49051	49144	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49052	49145	}
49053	49146	// ACCUMULATE ARGUMENTS - END
49054		- uint64_t return_to = 18446744073709549482LLU;
	49147	+ uint64_t return_to = 18446744073709549480LLU;
49055	49148	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
49056	49149	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49057	49150	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49060,7 +49153,7 @@
49060	49153	state.addr = 587881357514113024LLU; // emitpar___
49061	49154	break;
49062	49155	}
49063		- case 18446744073709549482LLU: // 99999999co'''''''''''''''
	49156	+ case 18446744073709549480LLU: // 99999999cm'''''''''''''''
49064	49157	{
49065	49158	fprintf(stdout, "%s", " = ");
49066	49159	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -49069,7 +49162,7 @@
49069	49162	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49070	49163	}
49071	49164	// ACCUMULATE ARGUMENTS - END
49072		- uint64_t return_to = 18446744073709549481LLU;
	49165	+ uint64_t return_to = 18446744073709549479LLU;
49073	49166	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49074	49167	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49075	49168	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49078,7 +49171,7 @@
49078	49171	state.addr = 839519665163075584LLU; // skip______
49079	49172	break;
49080	49173	}
49081		- case 18446744073709549481LLU: // 99999999cn'''''''''''''''
	49174	+ case 18446744073709549479LLU: // 99999999cl'''''''''''''''
49082	49175	{
49083	49176
49084	49177	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -49100,7 +49193,7 @@
49100	49193	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49101	49194	}
49102	49195	// ACCUMULATE ARGUMENTS - END
49103		- uint64_t return_to = 18446744073709549480LLU;
	49196	+ uint64_t return_to = 18446744073709549478LLU;
49104	49197	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49105	49198	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49106	49199	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49109,7 +49202,7 @@
49109	49202	state.addr = 23446349213393492LLU; // ASSERTINIT
49110	49203	break;
49111	49204	}
49112		- case 18446744073709549480LLU: // 99999999cm'''''''''''''''
	49205	+ case 18446744073709549478LLU: // 99999999ck'''''''''''''''
49113	49206	{
49114	49207	{
49115	49208	uint64_t arg = 0;

		@@ -49188,7 +49281,7 @@
49188	49281	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49189	49282	}
49190	49283	// ACCUMULATE ARGUMENTS - END
49191		- uint64_t return_to = 18446744073709549479LLU;
	49284	+ uint64_t return_to = 18446744073709549477LLU;
49192	49285	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49193	49286	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49194	49287	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49197,7 +49290,7 @@
49197	49290	state.addr = 293363126232490310LLU; // PROCVARREF
49198	49291	break;
49199	49292	}
49200		- case 18446744073709549479LLU: // 99999999cl'''''''''''''''
	49293	+ case 18446744073709549477LLU: // 99999999cj'''''''''''''''
49201	49294	{
49202	49295	// variable u64 initialize goes out of scope
49203	49296	// emitted destructur for type u64

		@@ -49218,7 +49311,7 @@
49218	49311	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49219	49312	}
49220	49313	// ACCUMULATE ARGUMENTS - END
49221		- uint64_t return_to = 18446744073709549478LLU;
	49314	+ uint64_t return_to = 18446744073709549476LLU;
49222	49315	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49223	49316	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49224	49317	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49227,7 +49320,7 @@
49227	49320	state.addr = 517555565476695680LLU; // assertu64_
49228	49321	break;
49229	49322	}
49230		- case 18446744073709549478LLU: // 99999999ck'''''''''''''''
	49323	+ case 18446744073709549476LLU: // 99999999ci'''''''''''''''
49231	49324	{
49232	49325	// ACCUMULATE ARGUMENTS - BEGIN
49233	49326	{

		@@ -49235,7 +49328,7 @@
49235	49328	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49236	49329	}
49237	49330	// ACCUMULATE ARGUMENTS - END
49238		- uint64_t return_to = 18446744073709549477LLU;
	49331	+ uint64_t return_to = 18446744073709549475LLU;
49239	49332	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49240	49333	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49241	49334	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49244,7 +49337,7 @@
49244	49337	state.addr = 839519665163075584LLU; // skip______
49245	49338	break;
49246	49339	}
49247		- case 18446744073709549477LLU: // 99999999cj'''''''''''''''
	49340	+ case 18446744073709549475LLU: // 99999999ch'''''''''''''''
49248	49341	{
49249	49342	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
49250	49343	fprintf(stdout, "%s", " \| ");

		@@ -49254,7 +49347,7 @@
49254	49347	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49255	49348	}
49256	49349	// ACCUMULATE ARGUMENTS - END
49257		- uint64_t return_to = 18446744073709549476LLU;
	49350	+ uint64_t return_to = 18446744073709549474LLU;
49258	49351	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49259	49352	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49260	49353	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49263,7 +49356,7 @@
49263	49356	state.addr = 839519665163075584LLU; // skip______
49264	49357	break;
49265	49358	}
49266		- case 18446744073709549476LLU: // 99999999ci'''''''''''''''
	49359	+ case 18446744073709549474LLU: // 99999999cg'''''''''''''''
49267	49360	{
49268	49361
49269	49362	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -49285,7 +49378,7 @@
49285	49378	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49286	49379	}
49287	49380	// ACCUMULATE ARGUMENTS - END
49288		- uint64_t return_to = 18446744073709549475LLU;
	49381	+ uint64_t return_to = 18446744073709549473LLU;
49289	49382	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49290	49383	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49291	49384	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49294,7 +49387,7 @@
49294	49387	state.addr = 23446349213393492LLU; // ASSERTINIT
49295	49388	break;
49296	49389	}
49297		- case 18446744073709549475LLU: // 99999999ch'''''''''''''''
	49390	+ case 18446744073709549473LLU: // 99999999cf'''''''''''''''
49298	49391	{
49299	49392	{
49300	49393	uint64_t arg = 0;

		@@ -49373,7 +49466,7 @@
49373	49466	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49374	49467	}
49375	49468	// ACCUMULATE ARGUMENTS - END
49376		- uint64_t return_to = 18446744073709549474LLU;
	49469	+ uint64_t return_to = 18446744073709549472LLU;
49377	49470	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49378	49471	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49379	49472	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49382,7 +49475,7 @@
49382	49475	state.addr = 293363126232490310LLU; // PROCVARREF
49383	49476	break;
49384	49477	}
49385		- case 18446744073709549474LLU: // 99999999cg'''''''''''''''
	49478	+ case 18446744073709549472LLU: // 99999999ce'''''''''''''''
49386	49479	{
49387	49480	// variable u64 initialize goes out of scope
49388	49481	// emitted destructur for type u64

		@@ -49403,7 +49496,7 @@
49403	49496	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49404	49497	}
49405	49498	// ACCUMULATE ARGUMENTS - END
49406		- uint64_t return_to = 18446744073709549473LLU;
	49499	+ uint64_t return_to = 18446744073709549471LLU;
49407	49500	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49408	49501	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49409	49502	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49412,7 +49505,7 @@
49412	49505	state.addr = 517555565476695680LLU; // assertu64_
49413	49506	break;
49414	49507	}
49415		- case 18446744073709549473LLU: // 99999999cf'''''''''''''''
	49508	+ case 18446744073709549471LLU: // 99999999cd'''''''''''''''
49416	49509	{
49417	49510	// ACCUMULATE ARGUMENTS - BEGIN
49418	49511	{

		@@ -49420,7 +49513,7 @@
49420	49513	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49421	49514	}
49422	49515	// ACCUMULATE ARGUMENTS - END
49423		- uint64_t return_to = 18446744073709549472LLU;
	49516	+ uint64_t return_to = 18446744073709549470LLU;
49424	49517	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49425	49518	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49426	49519	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49429,7 +49522,7 @@
49429	49522	state.addr = 839519665163075584LLU; // skip______
49430	49523	break;
49431	49524	}
49432		- case 18446744073709549472LLU: // 99999999ce'''''''''''''''
	49525	+ case 18446744073709549470LLU: // 99999999cc'''''''''''''''
49433	49526	{
49434	49527	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
49435	49528	fprintf(stdout, "%s", ";");

		@@ -49441,7 +49534,7 @@
49441	49534	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49442	49535	}
49443	49536	// ACCUMULATE ARGUMENTS - END
49444		- uint64_t return_to = 18446744073709549471LLU;
	49537	+ uint64_t return_to = 18446744073709549469LLU;
49445	49538	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49446	49539	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49447	49540	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49450,7 +49543,7 @@
49450	49543	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
49451	49544	break;
49452	49545	}
49453		- case 18446744073709549471LLU: // 99999999cd'''''''''''''''
	49546	+ case 18446744073709549469LLU: // 99999999cb'''''''''''''''
49454	49547	{
49455	49548	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
49456	49549	// variable type______ type______ goes out of scope

		@@ -49461,7 +49554,7 @@
49461	49554	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49462	49555	}
49463	49556	// ACCUMULATE ARGUMENTS - END
49464		- uint64_t return_to = 18446744073709549470LLU;
	49557	+ uint64_t return_to = 18446744073709549468LLU;
49465	49558	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49466	49559	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49467	49560	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49470,7 +49563,7 @@
49470	49563	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
49471	49564	break;
49472	49565	}
49473		- case 18446744073709549470LLU: // 99999999cc'''''''''''''''
	49566	+ case 18446744073709549468LLU: // 99999999ca'''''''''''''''
49474	49567	{
49475	49568	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
49476	49569	// variable u64 mutable___ goes out of scope

		@@ -49482,10 +49575,10 @@
49482	49575	// variable u64 id________ goes out of scope
49483	49576	// emitted destructur for type u64
49484	49577	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
49485		- state.addr = 18446744073709549488LLU; // 99999999cu'''''''''''''''
	49578	+ state.addr = 18446744073709549486LLU; // 99999999cs'''''''''''''''
49486	49579	break;
49487	49580	}
49488		- case 18446744073709549489LLU: // 99999999cv'''''''''''''''
	49581	+ case 18446744073709549487LLU: // 99999999ct'''''''''''''''
49489	49582	{
49490	49583
49491	49584	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 516079971752476672;

		@@ -49496,11 +49589,11 @@
49496	49589	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
49497	49590	}
49498	49591	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
49499		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549469LLU : 18446744073709549468LLU;
	49592	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549467LLU : 18446744073709549466LLU;
49500	49593	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
49501	49594	break;
49502	49595	}
49503		- case 18446744073709549469LLU: // 99999999cb'''''''''''''''
	49596	+ case 18446744073709549467LLU: // 99999999c$'''''''''''''''
49504	49597	{
49505	49598	{
49506	49599	uint64_t arg = 0;

		@@ -49527,7 +49620,7 @@
49527	49620	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49528	49621	}
49529	49622	// ACCUMULATE ARGUMENTS - END
49530		- uint64_t return_to = 18446744073709549466LLU;
	49623	+ uint64_t return_to = 18446744073709549464LLU;
49531	49624	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49532	49625	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49533	49626	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49536,7 +49629,7 @@
49536	49629	state.addr = 861504796319285248LLU; // typeu64___
49537	49630	break;
49538	49631	}
49539		- case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
	49632	+ case 18446744073709549464LLU: // 99999999cX'''''''''''''''
49540	49633	{
49541	49634	{
49542	49635	uint64_t arg = 0;

		@@ -49561,7 +49654,7 @@
49561	49654	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49562	49655	}
49563	49656	// ACCUMULATE ARGUMENTS - END
49564		- uint64_t return_to = 18446744073709549464LLU;
	49657	+ uint64_t return_to = 18446744073709549462LLU;
49565	49658	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49566	49659	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49567	49660	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49570,7 +49663,7 @@
49570	49663	state.addr = 861504796319285248LLU; // typeu64___
49571	49664	break;
49572	49665	}
49573		- case 18446744073709549464LLU: // 99999999cX'''''''''''''''
	49666	+ case 18446744073709549462LLU: // 99999999cV'''''''''''''''
49574	49667	{
49575	49668	{
49576	49669	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -49590,7 +49683,7 @@
49590	49683	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49591	49684	}
49592	49685	// ACCUMULATE ARGUMENTS - END
49593		- uint64_t return_to = 18446744073709549465LLU;
	49686	+ uint64_t return_to = 18446744073709549463LLU;
49594	49687	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49595	49688	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49596	49689	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49599,7 +49692,7 @@
49599	49692	state.addr = 819859607768530944LLU; // resdest___
49600	49693	break;
49601	49694	}
49602		- case 18446744073709549465LLU: // 99999999cY'''''''''''''''
	49695	+ case 18446744073709549463LLU: // 99999999cW'''''''''''''''
49603	49696	{
49604	49697	// ACCUMULATE ARGUMENTS - BEGIN
49605	49698	{

		@@ -49619,7 +49712,7 @@
49619	49712	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49620	49713	}
49621	49714	// ACCUMULATE ARGUMENTS - END
49622		- uint64_t return_to = 18446744073709549463LLU;
	49715	+ uint64_t return_to = 18446744073709549461LLU;
49623	49716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49624	49717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49625	49718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49628,7 +49721,7 @@
49628	49721	state.addr = 819857494882385920LLU; // res_u64___
49629	49722	break;
49630	49723	}
49631		- case 18446744073709549463LLU: // 99999999cW'''''''''''''''
	49724	+ case 18446744073709549461LLU: // 99999999cU'''''''''''''''
49632	49725	{
49633	49726	// ACCUMULATE ARGUMENTS - BEGIN
49634	49727	{

		@@ -49636,7 +49729,7 @@
49636	49729	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49637	49730	}
49638	49731	// ACCUMULATE ARGUMENTS - END
49639		- uint64_t return_to = 18446744073709549462LLU;
	49732	+ uint64_t return_to = 18446744073709549460LLU;
49640	49733	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49641	49734	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49642	49735	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49645,7 +49738,7 @@
49645	49738	state.addr = 839519665163075584LLU; // skip______
49646	49739	break;
49647	49740	}
49648		- case 18446744073709549462LLU: // 99999999cV'''''''''''''''
	49741	+ case 18446744073709549460LLU: // 99999999cT'''''''''''''''
49649	49742	{
49650	49743	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
49651	49744	fprintf(stdout, "%s", "\n ");

		@@ -49671,7 +49764,7 @@
49671	49764	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49672	49765	}
49673	49766	// ACCUMULATE ARGUMENTS - END
49674		- uint64_t return_to = 18446744073709549461LLU;
	49767	+ uint64_t return_to = 18446744073709549459LLU;
49675	49768	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
49676	49769	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49677	49770	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49680,7 +49773,7 @@
49680	49773	state.addr = 587881357514113024LLU; // emitpar___
49681	49774	break;
49682	49775	}
49683		- case 18446744073709549461LLU: // 99999999cU'''''''''''''''
	49776	+ case 18446744073709549459LLU: // 99999999cS'''''''''''''''
49684	49777	{
49685	49778	fprintf(stdout, "%s", " = ");
49686	49779	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -49689,7 +49782,7 @@
49689	49782	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49690	49783	}
49691	49784	// ACCUMULATE ARGUMENTS - END
49692		- uint64_t return_to = 18446744073709549460LLU;
	49785	+ uint64_t return_to = 18446744073709549458LLU;
49693	49786	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49694	49787	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49695	49788	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49698,7 +49791,7 @@
49698	49791	state.addr = 839519665163075584LLU; // skip______
49699	49792	break;
49700	49793	}
49701		- case 18446744073709549460LLU: // 99999999cT'''''''''''''''
	49794	+ case 18446744073709549458LLU: // 99999999cR'''''''''''''''
49702	49795	{
49703	49796
49704	49797	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -49720,7 +49813,7 @@
49720	49813	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49721	49814	}
49722	49815	// ACCUMULATE ARGUMENTS - END
49723		- uint64_t return_to = 18446744073709549459LLU;
	49816	+ uint64_t return_to = 18446744073709549457LLU;
49724	49817	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49725	49818	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49726	49819	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49729,7 +49822,7 @@
49729	49822	state.addr = 23446349213393492LLU; // ASSERTINIT
49730	49823	break;
49731	49824	}
49732		- case 18446744073709549459LLU: // 99999999cS'''''''''''''''
	49825	+ case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
49733	49826	{
49734	49827	{
49735	49828	uint64_t arg = 0;

		@@ -49808,7 +49901,7 @@
49808	49901	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49809	49902	}
49810	49903	// ACCUMULATE ARGUMENTS - END
49811		- uint64_t return_to = 18446744073709549458LLU;
	49904	+ uint64_t return_to = 18446744073709549456LLU;
49812	49905	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49813	49906	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49814	49907	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49817,7 +49910,7 @@
49817	49910	state.addr = 293363126232490310LLU; // PROCVARREF
49818	49911	break;
49819	49912	}
49820		- case 18446744073709549458LLU: // 99999999cR'''''''''''''''
	49913	+ case 18446744073709549456LLU: // 99999999cP'''''''''''''''
49821	49914	{
49822	49915	// variable u64 initialize goes out of scope
49823	49916	// emitted destructur for type u64

		@@ -49838,7 +49931,7 @@
49838	49931	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49839	49932	}
49840	49933	// ACCUMULATE ARGUMENTS - END
49841		- uint64_t return_to = 18446744073709549457LLU;
	49934	+ uint64_t return_to = 18446744073709549455LLU;
49842	49935	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
49843	49936	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49844	49937	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49847,7 +49940,7 @@
49847	49940	state.addr = 517555565476695680LLU; // assertu64_
49848	49941	break;
49849	49942	}
49850		- case 18446744073709549457LLU: // 99999999cQ'''''''''''''''
	49943	+ case 18446744073709549455LLU: // 99999999cO'''''''''''''''
49851	49944	{
49852	49945	// ACCUMULATE ARGUMENTS - BEGIN
49853	49946	{

		@@ -49855,7 +49948,7 @@
49855	49948	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49856	49949	}
49857	49950	// ACCUMULATE ARGUMENTS - END
49858		- uint64_t return_to = 18446744073709549456LLU;
	49951	+ uint64_t return_to = 18446744073709549454LLU;
49859	49952	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49860	49953	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49861	49954	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49864,7 +49957,7 @@
49864	49957	state.addr = 839519665163075584LLU; // skip______
49865	49958	break;
49866	49959	}
49867		- case 18446744073709549456LLU: // 99999999cP'''''''''''''''
	49960	+ case 18446744073709549454LLU: // 99999999cN'''''''''''''''
49868	49961	{
49869	49962	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
49870	49963	fprintf(stdout, "%s", " && ");

		@@ -49874,7 +49967,7 @@
49874	49967	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49875	49968	}
49876	49969	// ACCUMULATE ARGUMENTS - END
49877		- uint64_t return_to = 18446744073709549455LLU;
	49970	+ uint64_t return_to = 18446744073709549453LLU;
49878	49971	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
49879	49972	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49880	49973	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49883,7 +49976,7 @@
49883	49976	state.addr = 839519665163075584LLU; // skip______
49884	49977	break;
49885	49978	}
49886		- case 18446744073709549455LLU: // 99999999cO'''''''''''''''
	49979	+ case 18446744073709549453LLU: // 99999999cM'''''''''''''''
49887	49980	{
49888	49981
49889	49982	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -49905,7 +49998,7 @@
49905	49998	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49906	49999	}
49907	50000	// ACCUMULATE ARGUMENTS - END
49908		- uint64_t return_to = 18446744073709549454LLU;
	50001	+ uint64_t return_to = 18446744073709549452LLU;
49909	50002	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
49910	50003	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49911	50004	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -49914,7 +50007,7 @@
49914	50007	state.addr = 23446349213393492LLU; // ASSERTINIT
49915	50008	break;
49916	50009	}
49917		- case 18446744073709549454LLU: // 99999999cN'''''''''''''''
	50010	+ case 18446744073709549452LLU: // 99999999cL'''''''''''''''
49918	50011	{
49919	50012	{
49920	50013	uint64_t arg = 0;

		@@ -49993,7 +50086,7 @@
49993	50086	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
49994	50087	}
49995	50088	// ACCUMULATE ARGUMENTS - END
49996		- uint64_t return_to = 18446744073709549453LLU;
	50089	+ uint64_t return_to = 18446744073709549451LLU;
49997	50090	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
49998	50091	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
49999	50092	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50002,7 +50095,7 @@
50002	50095	state.addr = 293363126232490310LLU; // PROCVARREF
50003	50096	break;
50004	50097	}
50005		- case 18446744073709549453LLU: // 99999999cM'''''''''''''''
	50098	+ case 18446744073709549451LLU: // 99999999cK'''''''''''''''
50006	50099	{
50007	50100	// variable u64 initialize goes out of scope
50008	50101	// emitted destructur for type u64

		@@ -50023,7 +50116,7 @@
50023	50116	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50024	50117	}
50025	50118	// ACCUMULATE ARGUMENTS - END
50026		- uint64_t return_to = 18446744073709549452LLU;
	50119	+ uint64_t return_to = 18446744073709549450LLU;
50027	50120	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50028	50121	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50029	50122	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50032,7 +50125,7 @@
50032	50125	state.addr = 517555565476695680LLU; // assertu64_
50033	50126	break;
50034	50127	}
50035		- case 18446744073709549452LLU: // 99999999cL'''''''''''''''
	50128	+ case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
50036	50129	{
50037	50130	// ACCUMULATE ARGUMENTS - BEGIN
50038	50131	{

		@@ -50040,7 +50133,7 @@
50040	50133	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50041	50134	}
50042	50135	// ACCUMULATE ARGUMENTS - END
50043		- uint64_t return_to = 18446744073709549451LLU;
	50136	+ uint64_t return_to = 18446744073709549449LLU;
50044	50137	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50045	50138	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50046	50139	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50049,7 +50142,7 @@
50049	50142	state.addr = 839519665163075584LLU; // skip______
50050	50143	break;
50051	50144	}
50052		- case 18446744073709549451LLU: // 99999999cK'''''''''''''''
	50145	+ case 18446744073709549449LLU: // 99999999cI'''''''''''''''
50053	50146	{
50054	50147	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
50055	50148	fprintf(stdout, "%s", ";");

		@@ -50061,7 +50154,7 @@
50061	50154	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50062	50155	}
50063	50156	// ACCUMULATE ARGUMENTS - END
50064		- uint64_t return_to = 18446744073709549450LLU;
	50157	+ uint64_t return_to = 18446744073709549448LLU;
50065	50158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50066	50159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50067	50160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50070,7 +50163,7 @@
50070	50163	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
50071	50164	break;
50072	50165	}
50073		- case 18446744073709549450LLU: // 99999999cJ'''''''''''''''
	50166	+ case 18446744073709549448LLU: // 99999999cH'''''''''''''''
50074	50167	{
50075	50168	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
50076	50169	// variable type______ type______ goes out of scope

		@@ -50081,7 +50174,7 @@
50081	50174	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50082	50175	}
50083	50176	// ACCUMULATE ARGUMENTS - END
50084		- uint64_t return_to = 18446744073709549449LLU;
	50177	+ uint64_t return_to = 18446744073709549447LLU;
50085	50178	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50086	50179	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50087	50180	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50090,7 +50183,7 @@
50090	50183	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
50091	50184	break;
50092	50185	}
50093		- case 18446744073709549449LLU: // 99999999cI'''''''''''''''
	50186	+ case 18446744073709549447LLU: // 99999999cG'''''''''''''''
50094	50187	{
50095	50188	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
50096	50189	// variable u64 mutable___ goes out of scope

		@@ -50102,10 +50195,10 @@
50102	50195	// variable u64 id________ goes out of scope
50103	50196	// emitted destructur for type u64
50104	50197	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
50105		- state.addr = 18446744073709549467LLU; // 99999999c$'''''''''''''''
	50198	+ state.addr = 18446744073709549465LLU; // 99999999cY'''''''''''''''
50106	50199	break;
50107	50200	}
50108		- case 18446744073709549468LLU: // 99999999ca'''''''''''''''
	50201	+ case 18446744073709549466LLU: // 99999999cZ'''''''''''''''
50109	50202	{
50110	50203
50111	50204	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 769271111350222848;

		@@ -50116,11 +50209,11 @@
50116	50209	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
50117	50210	}
50118	50211	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50119		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549448LLU : 18446744073709549447LLU;
	50212	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549446LLU : 18446744073709549445LLU;
50120	50213	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
50121	50214	break;
50122	50215	}
50123		- case 18446744073709549448LLU: // 99999999cH'''''''''''''''
	50216	+ case 18446744073709549446LLU: // 99999999cF'''''''''''''''
50124	50217	{
50125	50218	{
50126	50219	uint64_t arg = 0;

		@@ -50147,7 +50240,7 @@
50147	50240	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50148	50241	}
50149	50242	// ACCUMULATE ARGUMENTS - END
50150		- uint64_t return_to = 18446744073709549445LLU;
	50243	+ uint64_t return_to = 18446744073709549443LLU;
50151	50244	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50152	50245	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50153	50246	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50156,7 +50249,7 @@
50156	50249	state.addr = 861504796319285248LLU; // typeu64___
50157	50250	break;
50158	50251	}
50159		- case 18446744073709549445LLU: // 99999999cE'''''''''''''''
	50252	+ case 18446744073709549443LLU: // 99999999cC'''''''''''''''
50160	50253	{
50161	50254	{
50162	50255	uint64_t arg = 0;

		@@ -50181,7 +50274,7 @@
50181	50274	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50182	50275	}
50183	50276	// ACCUMULATE ARGUMENTS - END
50184		- uint64_t return_to = 18446744073709549443LLU;
	50277	+ uint64_t return_to = 18446744073709549441LLU;
50185	50278	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50186	50279	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50187	50280	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50190,7 +50283,7 @@
50190	50283	state.addr = 861504796319285248LLU; // typeu64___
50191	50284	break;
50192	50285	}
50193		- case 18446744073709549443LLU: // 99999999cC'''''''''''''''
	50286	+ case 18446744073709549441LLU: // 99999999cA'''''''''''''''
50194	50287	{
50195	50288	{
50196	50289	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -50210,7 +50303,7 @@
50210	50303	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50211	50304	}
50212	50305	// ACCUMULATE ARGUMENTS - END
50213		- uint64_t return_to = 18446744073709549444LLU;
	50306	+ uint64_t return_to = 18446744073709549442LLU;
50214	50307	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50215	50308	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50216	50309	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50219,7 +50312,7 @@
50219	50312	state.addr = 819859607768530944LLU; // resdest___
50220	50313	break;
50221	50314	}
50222		- case 18446744073709549444LLU: // 99999999cD'''''''''''''''
	50315	+ case 18446744073709549442LLU: // 99999999cB'''''''''''''''
50223	50316	{
50224	50317	// ACCUMULATE ARGUMENTS - BEGIN
50225	50318	{

		@@ -50239,7 +50332,7 @@
50239	50332	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50240	50333	}
50241	50334	// ACCUMULATE ARGUMENTS - END
50242		- uint64_t return_to = 18446744073709549442LLU;
	50335	+ uint64_t return_to = 18446744073709549440LLU;
50243	50336	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50244	50337	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50245	50338	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50248,7 +50341,7 @@
50248	50341	state.addr = 819857494882385920LLU; // res_u64___
50249	50342	break;
50250	50343	}
50251		- case 18446744073709549442LLU: // 99999999cB'''''''''''''''
	50344	+ case 18446744073709549440LLU: // 99999999c_'''''''''''''''
50252	50345	{
50253	50346	// ACCUMULATE ARGUMENTS - BEGIN
50254	50347	{

		@@ -50256,7 +50349,7 @@
50256	50349	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50257	50350	}
50258	50351	// ACCUMULATE ARGUMENTS - END
50259		- uint64_t return_to = 18446744073709549441LLU;
	50352	+ uint64_t return_to = 18446744073709549439LLU;
50260	50353	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50261	50354	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50262	50355	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50265,7 +50358,7 @@
50265	50358	state.addr = 839519665163075584LLU; // skip______
50266	50359	break;
50267	50360	}
50268		- case 18446744073709549441LLU: // 99999999cA'''''''''''''''
	50361	+ case 18446744073709549439LLU: // 99999999b9'''''''''''''''
50269	50362	{
50270	50363	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
50271	50364	fprintf(stdout, "%s", "\n ");

		@@ -50291,7 +50384,7 @@
50291	50384	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50292	50385	}
50293	50386	// ACCUMULATE ARGUMENTS - END
50294		- uint64_t return_to = 18446744073709549440LLU;
	50387	+ uint64_t return_to = 18446744073709549438LLU;
50295	50388	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
50296	50389	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50297	50390	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50300,7 +50393,7 @@
50300	50393	state.addr = 587881357514113024LLU; // emitpar___
50301	50394	break;
50302	50395	}
50303		- case 18446744073709549440LLU: // 99999999c_'''''''''''''''
	50396	+ case 18446744073709549438LLU: // 99999999b8'''''''''''''''
50304	50397	{
50305	50398	fprintf(stdout, "%s", " = ");
50306	50399	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -50309,7 +50402,7 @@
50309	50402	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50310	50403	}
50311	50404	// ACCUMULATE ARGUMENTS - END
50312		- uint64_t return_to = 18446744073709549439LLU;
	50405	+ uint64_t return_to = 18446744073709549437LLU;
50313	50406	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50314	50407	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50315	50408	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50318,7 +50411,7 @@
50318	50411	state.addr = 839519665163075584LLU; // skip______
50319	50412	break;
50320	50413	}
50321		- case 18446744073709549439LLU: // 99999999b9'''''''''''''''
	50414	+ case 18446744073709549437LLU: // 99999999b7'''''''''''''''
50322	50415	{
50323	50416
50324	50417	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -50340,7 +50433,7 @@
50340	50433	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50341	50434	}
50342	50435	// ACCUMULATE ARGUMENTS - END
50343		- uint64_t return_to = 18446744073709549438LLU;
	50436	+ uint64_t return_to = 18446744073709549436LLU;
50344	50437	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50345	50438	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50346	50439	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50349,7 +50442,7 @@
50349	50442	state.addr = 23446349213393492LLU; // ASSERTINIT
50350	50443	break;
50351	50444	}
50352		- case 18446744073709549438LLU: // 99999999b8'''''''''''''''
	50445	+ case 18446744073709549436LLU: // 99999999b6'''''''''''''''
50353	50446	{
50354	50447	{
50355	50448	uint64_t arg = 0;

		@@ -50428,7 +50521,7 @@
50428	50521	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50429	50522	}
50430	50523	// ACCUMULATE ARGUMENTS - END
50431		- uint64_t return_to = 18446744073709549437LLU;
	50524	+ uint64_t return_to = 18446744073709549435LLU;
50432	50525	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
50433	50526	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50434	50527	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50437,7 +50530,7 @@
50437	50530	state.addr = 293363126232490310LLU; // PROCVARREF
50438	50531	break;
50439	50532	}
50440		- case 18446744073709549437LLU: // 99999999b7'''''''''''''''
	50533	+ case 18446744073709549435LLU: // 99999999b5'''''''''''''''
50441	50534	{
50442	50535	// variable u64 initialize goes out of scope
50443	50536	// emitted destructur for type u64

		@@ -50458,7 +50551,7 @@
50458	50551	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50459	50552	}
50460	50553	// ACCUMULATE ARGUMENTS - END
50461		- uint64_t return_to = 18446744073709549436LLU;
	50554	+ uint64_t return_to = 18446744073709549434LLU;
50462	50555	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50463	50556	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50464	50557	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50467,7 +50560,7 @@
50467	50560	state.addr = 517555565476695680LLU; // assertu64_
50468	50561	break;
50469	50562	}
50470		- case 18446744073709549436LLU: // 99999999b6'''''''''''''''
	50563	+ case 18446744073709549434LLU: // 99999999b4'''''''''''''''
50471	50564	{
50472	50565	// ACCUMULATE ARGUMENTS - BEGIN
50473	50566	{

		@@ -50475,7 +50568,7 @@
50475	50568	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50476	50569	}
50477	50570	// ACCUMULATE ARGUMENTS - END
50478		- uint64_t return_to = 18446744073709549435LLU;
	50571	+ uint64_t return_to = 18446744073709549433LLU;
50479	50572	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50480	50573	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50481	50574	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50484,7 +50577,7 @@
50484	50577	state.addr = 839519665163075584LLU; // skip______
50485	50578	break;
50486	50579	}
50487		- case 18446744073709549435LLU: // 99999999b5'''''''''''''''
	50580	+ case 18446744073709549433LLU: // 99999999b3'''''''''''''''
50488	50581	{
50489	50582	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
50490	50583	fprintf(stdout, "%s", " \|\| ");

		@@ -50494,7 +50587,7 @@
50494	50587	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50495	50588	}
50496	50589	// ACCUMULATE ARGUMENTS - END
50497		- uint64_t return_to = 18446744073709549434LLU;
	50590	+ uint64_t return_to = 18446744073709549432LLU;
50498	50591	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50499	50592	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50500	50593	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50503,7 +50596,7 @@
50503	50596	state.addr = 839519665163075584LLU; // skip______
50504	50597	break;
50505	50598	}
50506		- case 18446744073709549434LLU: // 99999999b4'''''''''''''''
	50599	+ case 18446744073709549432LLU: // 99999999b2'''''''''''''''
50507	50600	{
50508	50601
50509	50602	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -50525,7 +50618,7 @@
50525	50618	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50526	50619	}
50527	50620	// ACCUMULATE ARGUMENTS - END
50528		- uint64_t return_to = 18446744073709549433LLU;
	50621	+ uint64_t return_to = 18446744073709549431LLU;
50529	50622	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50530	50623	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50531	50624	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50534,7 +50627,7 @@
50534	50627	state.addr = 23446349213393492LLU; // ASSERTINIT
50535	50628	break;
50536	50629	}
50537		- case 18446744073709549433LLU: // 99999999b3'''''''''''''''
	50630	+ case 18446744073709549431LLU: // 99999999b1'''''''''''''''
50538	50631	{
50539	50632	{
50540	50633	uint64_t arg = 0;

		@@ -50613,7 +50706,7 @@
50613	50706	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50614	50707	}
50615	50708	// ACCUMULATE ARGUMENTS - END
50616		- uint64_t return_to = 18446744073709549432LLU;
	50709	+ uint64_t return_to = 18446744073709549430LLU;
50617	50710	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
50618	50711	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50619	50712	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50622,7 +50715,7 @@
50622	50715	state.addr = 293363126232490310LLU; // PROCVARREF
50623	50716	break;
50624	50717	}
50625		- case 18446744073709549432LLU: // 99999999b2'''''''''''''''
	50718	+ case 18446744073709549430LLU: // 99999999b0'''''''''''''''
50626	50719	{
50627	50720	// variable u64 initialize goes out of scope
50628	50721	// emitted destructur for type u64

		@@ -50643,7 +50736,7 @@
50643	50736	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50644	50737	}
50645	50738	// ACCUMULATE ARGUMENTS - END
50646		- uint64_t return_to = 18446744073709549431LLU;
	50739	+ uint64_t return_to = 18446744073709549429LLU;
50647	50740	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
50648	50741	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50649	50742	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50652,7 +50745,7 @@
50652	50745	state.addr = 517555565476695680LLU; // assertu64_
50653	50746	break;
50654	50747	}
50655		- case 18446744073709549431LLU: // 99999999b1'''''''''''''''
	50748	+ case 18446744073709549429LLU: // 99999999bz'''''''''''''''
50656	50749	{
50657	50750	// ACCUMULATE ARGUMENTS - BEGIN
50658	50751	{

		@@ -50660,7 +50753,7 @@
50660	50753	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50661	50754	}
50662	50755	// ACCUMULATE ARGUMENTS - END
50663		- uint64_t return_to = 18446744073709549430LLU;
	50756	+ uint64_t return_to = 18446744073709549428LLU;
50664	50757	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50665	50758	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50666	50759	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50669,7 +50762,7 @@
50669	50762	state.addr = 839519665163075584LLU; // skip______
50670	50763	break;
50671	50764	}
50672		- case 18446744073709549430LLU: // 99999999b0'''''''''''''''
	50765	+ case 18446744073709549428LLU: // 99999999by'''''''''''''''
50673	50766	{
50674	50767	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
50675	50768	fprintf(stdout, "%s", ";");

		@@ -50681,7 +50774,7 @@
50681	50774	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50682	50775	}
50683	50776	// ACCUMULATE ARGUMENTS - END
50684		- uint64_t return_to = 18446744073709549429LLU;
	50777	+ uint64_t return_to = 18446744073709549427LLU;
50685	50778	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50686	50779	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50687	50780	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50690,7 +50783,7 @@
50690	50783	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
50691	50784	break;
50692	50785	}
50693		- case 18446744073709549429LLU: // 99999999bz'''''''''''''''
	50786	+ case 18446744073709549427LLU: // 99999999bx'''''''''''''''
50694	50787	{
50695	50788	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
50696	50789	// variable type______ type______ goes out of scope

		@@ -50701,7 +50794,7 @@
50701	50794	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50702	50795	}
50703	50796	// ACCUMULATE ARGUMENTS - END
50704		- uint64_t return_to = 18446744073709549428LLU;
	50797	+ uint64_t return_to = 18446744073709549426LLU;
50705	50798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50706	50799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50707	50800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50710,7 +50803,7 @@
50710	50803	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
50711	50804	break;
50712	50805	}
50713		- case 18446744073709549428LLU: // 99999999by'''''''''''''''
	50806	+ case 18446744073709549426LLU: // 99999999bw'''''''''''''''
50714	50807	{
50715	50808	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
50716	50809	// variable u64 mutable___ goes out of scope

		@@ -50722,10 +50815,10 @@
50722	50815	// variable u64 id________ goes out of scope
50723	50816	// emitted destructur for type u64
50724	50817	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
50725		- state.addr = 18446744073709549446LLU; // 99999999cF'''''''''''''''
	50818	+ state.addr = 18446744073709549444LLU; // 99999999cD'''''''''''''''
50726	50819	break;
50727	50820	}
50728		- case 18446744073709549447LLU: // 99999999cG'''''''''''''''
	50821	+ case 18446744073709549445LLU: // 99999999cE'''''''''''''''
50729	50822	{
50730	50823
50731	50824	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604158353408;

		@@ -50736,11 +50829,11 @@
50736	50829	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
50737	50830	}
50738	50831	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
50739		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549427LLU : 18446744073709549426LLU;
	50832	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549425LLU : 18446744073709549424LLU;
50740	50833	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
50741	50834	break;
50742	50835	}
50743		- case 18446744073709549427LLU: // 99999999bx'''''''''''''''
	50836	+ case 18446744073709549425LLU: // 99999999bv'''''''''''''''
50744	50837	{
50745	50838	{
50746	50839	uint64_t arg = 0;

		@@ -50767,7 +50860,7 @@
50767	50860	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50768	50861	}
50769	50862	// ACCUMULATE ARGUMENTS - END
50770		- uint64_t return_to = 18446744073709549424LLU;
	50863	+ uint64_t return_to = 18446744073709549422LLU;
50771	50864	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50772	50865	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50773	50866	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50776,7 +50869,7 @@
50776	50869	state.addr = 861504796319285248LLU; // typeu64___
50777	50870	break;
50778	50871	}
50779		- case 18446744073709549424LLU: // 99999999bu'''''''''''''''
	50872	+ case 18446744073709549422LLU: // 99999999bs'''''''''''''''
50780	50873	{
50781	50874	{
50782	50875	uint64_t arg = 0;

		@@ -50801,7 +50894,7 @@
50801	50894	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50802	50895	}
50803	50896	// ACCUMULATE ARGUMENTS - END
50804		- uint64_t return_to = 18446744073709549422LLU;
	50897	+ uint64_t return_to = 18446744073709549420LLU;
50805	50898	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50806	50899	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50807	50900	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50810,7 +50903,7 @@
50810	50903	state.addr = 861504796319285248LLU; // typeu64___
50811	50904	break;
50812	50905	}
50813		- case 18446744073709549422LLU: // 99999999bs'''''''''''''''
	50906	+ case 18446744073709549420LLU: // 99999999bq'''''''''''''''
50814	50907	{
50815	50908	{
50816	50909	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -50830,7 +50923,7 @@
50830	50923	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50831	50924	}
50832	50925	// ACCUMULATE ARGUMENTS - END
50833		- uint64_t return_to = 18446744073709549423LLU;
	50926	+ uint64_t return_to = 18446744073709549421LLU;
50834	50927	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50835	50928	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50836	50929	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50839,7 +50932,7 @@
50839	50932	state.addr = 819859607768530944LLU; // resdest___
50840	50933	break;
50841	50934	}
50842		- case 18446744073709549423LLU: // 99999999bt'''''''''''''''
	50935	+ case 18446744073709549421LLU: // 99999999br'''''''''''''''
50843	50936	{
50844	50937	// ACCUMULATE ARGUMENTS - BEGIN
50845	50938	{

		@@ -50859,7 +50952,7 @@
50859	50952	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50860	50953	}
50861	50954	// ACCUMULATE ARGUMENTS - END
50862		- uint64_t return_to = 18446744073709549421LLU;
	50955	+ uint64_t return_to = 18446744073709549419LLU;
50863	50956	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50864	50957	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50865	50958	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50868,7 +50961,7 @@
50868	50961	state.addr = 819857494882385920LLU; // res_u64___
50869	50962	break;
50870	50963	}
50871		- case 18446744073709549421LLU: // 99999999br'''''''''''''''
	50964	+ case 18446744073709549419LLU: // 99999999bp'''''''''''''''
50872	50965	{
50873	50966	// ACCUMULATE ARGUMENTS - BEGIN
50874	50967	{

		@@ -50876,7 +50969,7 @@
50876	50969	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50877	50970	}
50878	50971	// ACCUMULATE ARGUMENTS - END
50879		- uint64_t return_to = 18446744073709549420LLU;
	50972	+ uint64_t return_to = 18446744073709549418LLU;
50880	50973	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50881	50974	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50882	50975	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50885,7 +50978,7 @@
50885	50978	state.addr = 839519665163075584LLU; // skip______
50886	50979	break;
50887	50980	}
50888		- case 18446744073709549420LLU: // 99999999bq'''''''''''''''
	50981	+ case 18446744073709549418LLU: // 99999999bo'''''''''''''''
50889	50982	{
50890	50983	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
50891	50984	fprintf(stdout, "%s", "\n ");

		@@ -50911,7 +51004,7 @@
50911	51004	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50912	51005	}
50913	51006	// ACCUMULATE ARGUMENTS - END
50914		- uint64_t return_to = 18446744073709549419LLU;
	51007	+ uint64_t return_to = 18446744073709549417LLU;
50915	51008	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
50916	51009	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50917	51010	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50920,7 +51013,7 @@
50920	51013	state.addr = 587881357514113024LLU; // emitpar___
50921	51014	break;
50922	51015	}
50923		- case 18446744073709549419LLU: // 99999999bp'''''''''''''''
	51016	+ case 18446744073709549417LLU: // 99999999bn'''''''''''''''
50924	51017	{
50925	51018	fprintf(stdout, "%s", " = ");
50926	51019	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -50929,7 +51022,7 @@
50929	51022	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50930	51023	}
50931	51024	// ACCUMULATE ARGUMENTS - END
50932		- uint64_t return_to = 18446744073709549418LLU;
	51025	+ uint64_t return_to = 18446744073709549416LLU;
50933	51026	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
50934	51027	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50935	51028	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50938,7 +51031,7 @@
50938	51031	state.addr = 839519665163075584LLU; // skip______
50939	51032	break;
50940	51033	}
50941		- case 18446744073709549418LLU: // 99999999bo'''''''''''''''
	51034	+ case 18446744073709549416LLU: // 99999999bm'''''''''''''''
50942	51035	{
50943	51036
50944	51037	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -50960,7 +51053,7 @@
50960	51053	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
50961	51054	}
50962	51055	// ACCUMULATE ARGUMENTS - END
50963		- uint64_t return_to = 18446744073709549417LLU;
	51056	+ uint64_t return_to = 18446744073709549415LLU;
50964	51057	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
50965	51058	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
50966	51059	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -50969,7 +51062,7 @@
50969	51062	state.addr = 23446349213393492LLU; // ASSERTINIT
50970	51063	break;
50971	51064	}
50972		- case 18446744073709549417LLU: // 99999999bn'''''''''''''''
	51065	+ case 18446744073709549415LLU: // 99999999bl'''''''''''''''
50973	51066	{
50974	51067	{
50975	51068	uint64_t arg = 0;

		@@ -51048,7 +51141,7 @@
51048	51141	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51049	51142	}
51050	51143	// ACCUMULATE ARGUMENTS - END
51051		- uint64_t return_to = 18446744073709549416LLU;
	51144	+ uint64_t return_to = 18446744073709549414LLU;
51052	51145	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
51053	51146	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51054	51147	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51057,7 +51150,7 @@
51057	51150	state.addr = 293363126232490310LLU; // PROCVARREF
51058	51151	break;
51059	51152	}
51060		- case 18446744073709549416LLU: // 99999999bm'''''''''''''''
	51153	+ case 18446744073709549414LLU: // 99999999bk'''''''''''''''
51061	51154	{
51062	51155	// variable u64 initialize goes out of scope
51063	51156	// emitted destructur for type u64

		@@ -51078,7 +51171,7 @@
51078	51171	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51079	51172	}
51080	51173	// ACCUMULATE ARGUMENTS - END
51081		- uint64_t return_to = 18446744073709549415LLU;
	51174	+ uint64_t return_to = 18446744073709549413LLU;
51082	51175	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
51083	51176	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51084	51177	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51087,7 +51180,7 @@
51087	51180	state.addr = 517555565476695680LLU; // assertu64_
51088	51181	break;
51089	51182	}
51090		- case 18446744073709549415LLU: // 99999999bl'''''''''''''''
	51183	+ case 18446744073709549413LLU: // 99999999bj'''''''''''''''
51091	51184	{
51092	51185	// ACCUMULATE ARGUMENTS - BEGIN
51093	51186	{

		@@ -51095,7 +51188,7 @@
51095	51188	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51096	51189	}
51097	51190	// ACCUMULATE ARGUMENTS - END
51098		- uint64_t return_to = 18446744073709549414LLU;
	51191	+ uint64_t return_to = 18446744073709549412LLU;
51099	51192	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51100	51193	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51101	51194	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51104,7 +51197,7 @@
51104	51197	state.addr = 839519665163075584LLU; // skip______
51105	51198	break;
51106	51199	}
51107		- case 18446744073709549414LLU: // 99999999bk'''''''''''''''
	51200	+ case 18446744073709549412LLU: // 99999999bi'''''''''''''''
51108	51201	{
51109	51202	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
51110	51203	fprintf(stdout, "%s", " << ");

		@@ -51114,7 +51207,7 @@
51114	51207	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51115	51208	}
51116	51209	// ACCUMULATE ARGUMENTS - END
51117		- uint64_t return_to = 18446744073709549413LLU;
	51210	+ uint64_t return_to = 18446744073709549411LLU;
51118	51211	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51119	51212	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51120	51213	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51123,7 +51216,7 @@
51123	51216	state.addr = 839519665163075584LLU; // skip______
51124	51217	break;
51125	51218	}
51126		- case 18446744073709549413LLU: // 99999999bj'''''''''''''''
	51219	+ case 18446744073709549411LLU: // 99999999bh'''''''''''''''
51127	51220	{
51128	51221
51129	51222	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -51145,7 +51238,7 @@
51145	51238	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51146	51239	}
51147	51240	// ACCUMULATE ARGUMENTS - END
51148		- uint64_t return_to = 18446744073709549412LLU;
	51241	+ uint64_t return_to = 18446744073709549410LLU;
51149	51242	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51150	51243	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51151	51244	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51154,7 +51247,7 @@
51154	51247	state.addr = 23446349213393492LLU; // ASSERTINIT
51155	51248	break;
51156	51249	}
51157		- case 18446744073709549412LLU: // 99999999bi'''''''''''''''
	51250	+ case 18446744073709549410LLU: // 99999999bg'''''''''''''''
51158	51251	{
51159	51252	{
51160	51253	uint64_t arg = 0;

		@@ -51233,7 +51326,7 @@
51233	51326	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51234	51327	}
51235	51328	// ACCUMULATE ARGUMENTS - END
51236		- uint64_t return_to = 18446744073709549411LLU;
	51329	+ uint64_t return_to = 18446744073709549409LLU;
51237	51330	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
51238	51331	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51239	51332	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51242,7 +51335,7 @@
51242	51335	state.addr = 293363126232490310LLU; // PROCVARREF
51243	51336	break;
51244	51337	}
51245		- case 18446744073709549411LLU: // 99999999bh'''''''''''''''
	51338	+ case 18446744073709549409LLU: // 99999999bf'''''''''''''''
51246	51339	{
51247	51340	// variable u64 initialize goes out of scope
51248	51341	// emitted destructur for type u64

		@@ -51263,7 +51356,7 @@
51263	51356	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51264	51357	}
51265	51358	// ACCUMULATE ARGUMENTS - END
51266		- uint64_t return_to = 18446744073709549410LLU;
	51359	+ uint64_t return_to = 18446744073709549408LLU;
51267	51360	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
51268	51361	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51269	51362	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51272,7 +51365,7 @@
51272	51365	state.addr = 517555565476695680LLU; // assertu64_
51273	51366	break;
51274	51367	}
51275		- case 18446744073709549410LLU: // 99999999bg'''''''''''''''
	51368	+ case 18446744073709549408LLU: // 99999999be'''''''''''''''
51276	51369	{
51277	51370	// ACCUMULATE ARGUMENTS - BEGIN
51278	51371	{

		@@ -51280,7 +51373,7 @@
51280	51373	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51281	51374	}
51282	51375	// ACCUMULATE ARGUMENTS - END
51283		- uint64_t return_to = 18446744073709549409LLU;
	51376	+ uint64_t return_to = 18446744073709549407LLU;
51284	51377	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51285	51378	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51286	51379	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51289,7 +51382,7 @@
51289	51382	state.addr = 839519665163075584LLU; // skip______
51290	51383	break;
51291	51384	}
51292		- case 18446744073709549409LLU: // 99999999bf'''''''''''''''
	51385	+ case 18446744073709549407LLU: // 99999999bd'''''''''''''''
51293	51386	{
51294	51387	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
51295	51388	fprintf(stdout, "%s", ";");

		@@ -51301,7 +51394,7 @@
51301	51394	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51302	51395	}
51303	51396	// ACCUMULATE ARGUMENTS - END
51304		- uint64_t return_to = 18446744073709549408LLU;
	51397	+ uint64_t return_to = 18446744073709549406LLU;
51305	51398	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51306	51399	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51307	51400	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51310,7 +51403,7 @@
51310	51403	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
51311	51404	break;
51312	51405	}
51313		- case 18446744073709549408LLU: // 99999999be'''''''''''''''
	51406	+ case 18446744073709549406LLU: // 99999999bc'''''''''''''''
51314	51407	{
51315	51408	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
51316	51409	// variable type______ type______ goes out of scope

		@@ -51321,7 +51414,7 @@
51321	51414	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51322	51415	}
51323	51416	// ACCUMULATE ARGUMENTS - END
51324		- uint64_t return_to = 18446744073709549407LLU;
	51417	+ uint64_t return_to = 18446744073709549405LLU;
51325	51418	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51326	51419	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51327	51420	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51330,7 +51423,7 @@
51330	51423	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
51331	51424	break;
51332	51425	}
51333		- case 18446744073709549407LLU: // 99999999bd'''''''''''''''
	51426	+ case 18446744073709549405LLU: // 99999999bb'''''''''''''''
51334	51427	{
51335	51428	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
51336	51429	// variable u64 mutable___ goes out of scope

		@@ -51342,10 +51435,10 @@
51342	51435	// variable u64 id________ goes out of scope
51343	51436	// emitted destructur for type u64
51344	51437	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
51345		- state.addr = 18446744073709549425LLU; // 99999999bv'''''''''''''''
	51438	+ state.addr = 18446744073709549423LLU; // 99999999bt'''''''''''''''
51346	51439	break;
51347	51440	}
51348		- case 18446744073709549426LLU: // 99999999bw'''''''''''''''
	51441	+ case 18446744073709549424LLU: // 99999999bu'''''''''''''''
51349	51442	{
51350	51443
51351	51444	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604259016704;

		@@ -51356,11 +51449,11 @@
51356	51449	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
51357	51450	}
51358	51451	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51359		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549406LLU : 18446744073709549405LLU;
	51452	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549404LLU : 18446744073709549403LLU;
51360	51453	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
51361	51454	break;
51362	51455	}
51363		- case 18446744073709549406LLU: // 99999999bc'''''''''''''''
	51456	+ case 18446744073709549404LLU: // 99999999ba'''''''''''''''
51364	51457	{
51365	51458	{
51366	51459	uint64_t arg = 0;

		@@ -51387,7 +51480,7 @@
51387	51480	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51388	51481	}
51389	51482	// ACCUMULATE ARGUMENTS - END
51390		- uint64_t return_to = 18446744073709549403LLU;
	51483	+ uint64_t return_to = 18446744073709549401LLU;
51391	51484	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51392	51485	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51393	51486	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51396,7 +51489,7 @@
51396	51489	state.addr = 861504796319285248LLU; // typeu64___
51397	51490	break;
51398	51491	}
51399		- case 18446744073709549403LLU: // 99999999b$'''''''''''''''
	51492	+ case 18446744073709549401LLU: // 99999999bY'''''''''''''''
51400	51493	{
51401	51494	{
51402	51495	uint64_t arg = 0;

		@@ -51421,7 +51514,7 @@
51421	51514	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51422	51515	}
51423	51516	// ACCUMULATE ARGUMENTS - END
51424		- uint64_t return_to = 18446744073709549401LLU;
	51517	+ uint64_t return_to = 18446744073709549399LLU;
51425	51518	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51426	51519	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51427	51520	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51430,7 +51523,7 @@
51430	51523	state.addr = 861504796319285248LLU; // typeu64___
51431	51524	break;
51432	51525	}
51433		- case 18446744073709549401LLU: // 99999999bY'''''''''''''''
	51526	+ case 18446744073709549399LLU: // 99999999bW'''''''''''''''
51434	51527	{
51435	51528	{
51436	51529	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -51450,7 +51543,7 @@
51450	51543	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51451	51544	}
51452	51545	// ACCUMULATE ARGUMENTS - END
51453		- uint64_t return_to = 18446744073709549402LLU;
	51546	+ uint64_t return_to = 18446744073709549400LLU;
51454	51547	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51455	51548	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51456	51549	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51459,7 +51552,7 @@
51459	51552	state.addr = 819859607768530944LLU; // resdest___
51460	51553	break;
51461	51554	}
51462		- case 18446744073709549402LLU: // 99999999bZ'''''''''''''''
	51555	+ case 18446744073709549400LLU: // 99999999bX'''''''''''''''
51463	51556	{
51464	51557	// ACCUMULATE ARGUMENTS - BEGIN
51465	51558	{

		@@ -51479,7 +51572,7 @@
51479	51572	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51480	51573	}
51481	51574	// ACCUMULATE ARGUMENTS - END
51482		- uint64_t return_to = 18446744073709549400LLU;
	51575	+ uint64_t return_to = 18446744073709549398LLU;
51483	51576	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51484	51577	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51485	51578	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51488,7 +51581,7 @@
51488	51581	state.addr = 819857494882385920LLU; // res_u64___
51489	51582	break;
51490	51583	}
51491		- case 18446744073709549400LLU: // 99999999bX'''''''''''''''
	51584	+ case 18446744073709549398LLU: // 99999999bV'''''''''''''''
51492	51585	{
51493	51586	// ACCUMULATE ARGUMENTS - BEGIN
51494	51587	{

		@@ -51496,7 +51589,7 @@
51496	51589	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51497	51590	}
51498	51591	// ACCUMULATE ARGUMENTS - END
51499		- uint64_t return_to = 18446744073709549399LLU;
	51592	+ uint64_t return_to = 18446744073709549397LLU;
51500	51593	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51501	51594	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51502	51595	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51505,7 +51598,7 @@
51505	51598	state.addr = 839519665163075584LLU; // skip______
51506	51599	break;
51507	51600	}
51508		- case 18446744073709549399LLU: // 99999999bW'''''''''''''''
	51601	+ case 18446744073709549397LLU: // 99999999bU'''''''''''''''
51509	51602	{
51510	51603	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
51511	51604	fprintf(stdout, "%s", "\n ");

		@@ -51531,7 +51624,7 @@
51531	51624	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51532	51625	}
51533	51626	// ACCUMULATE ARGUMENTS - END
51534		- uint64_t return_to = 18446744073709549398LLU;
	51627	+ uint64_t return_to = 18446744073709549396LLU;
51535	51628	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
51536	51629	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51537	51630	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51540,7 +51633,7 @@
51540	51633	state.addr = 587881357514113024LLU; // emitpar___
51541	51634	break;
51542	51635	}
51543		- case 18446744073709549398LLU: // 99999999bV'''''''''''''''
	51636	+ case 18446744073709549396LLU: // 99999999bT'''''''''''''''
51544	51637	{
51545	51638	fprintf(stdout, "%s", " = ");
51546	51639	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -51549,7 +51642,7 @@
51549	51642	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51550	51643	}
51551	51644	// ACCUMULATE ARGUMENTS - END
51552		- uint64_t return_to = 18446744073709549397LLU;
	51645	+ uint64_t return_to = 18446744073709549395LLU;
51553	51646	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51554	51647	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51555	51648	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51558,7 +51651,7 @@
51558	51651	state.addr = 839519665163075584LLU; // skip______
51559	51652	break;
51560	51653	}
51561		- case 18446744073709549397LLU: // 99999999bU'''''''''''''''
	51654	+ case 18446744073709549395LLU: // 99999999bS'''''''''''''''
51562	51655	{
51563	51656
51564	51657	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -51580,7 +51673,7 @@
51580	51673	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51581	51674	}
51582	51675	// ACCUMULATE ARGUMENTS - END
51583		- uint64_t return_to = 18446744073709549396LLU;
	51676	+ uint64_t return_to = 18446744073709549394LLU;
51584	51677	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51585	51678	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51586	51679	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51589,7 +51682,7 @@
51589	51682	state.addr = 23446349213393492LLU; // ASSERTINIT
51590	51683	break;
51591	51684	}
51592		- case 18446744073709549396LLU: // 99999999bT'''''''''''''''
	51685	+ case 18446744073709549394LLU: // 99999999bR'''''''''''''''
51593	51686	{
51594	51687	{
51595	51688	uint64_t arg = 0;

		@@ -51668,7 +51761,7 @@
51668	51761	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51669	51762	}
51670	51763	// ACCUMULATE ARGUMENTS - END
51671		- uint64_t return_to = 18446744073709549395LLU;
	51764	+ uint64_t return_to = 18446744073709549393LLU;
51672	51765	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
51673	51766	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51674	51767	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51677,7 +51770,7 @@
51677	51770	state.addr = 293363126232490310LLU; // PROCVARREF
51678	51771	break;
51679	51772	}
51680		- case 18446744073709549395LLU: // 99999999bS'''''''''''''''
	51773	+ case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
51681	51774	{
51682	51775	// variable u64 initialize goes out of scope
51683	51776	// emitted destructur for type u64

		@@ -51698,7 +51791,7 @@
51698	51791	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51699	51792	}
51700	51793	// ACCUMULATE ARGUMENTS - END
51701		- uint64_t return_to = 18446744073709549394LLU;
	51794	+ uint64_t return_to = 18446744073709549392LLU;
51702	51795	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
51703	51796	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51704	51797	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51707,7 +51800,7 @@
51707	51800	state.addr = 517555565476695680LLU; // assertu64_
51708	51801	break;
51709	51802	}
51710		- case 18446744073709549394LLU: // 99999999bR'''''''''''''''
	51803	+ case 18446744073709549392LLU: // 99999999bP'''''''''''''''
51711	51804	{
51712	51805	// ACCUMULATE ARGUMENTS - BEGIN
51713	51806	{

		@@ -51715,7 +51808,7 @@
51715	51808	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51716	51809	}
51717	51810	// ACCUMULATE ARGUMENTS - END
51718		- uint64_t return_to = 18446744073709549393LLU;
	51811	+ uint64_t return_to = 18446744073709549391LLU;
51719	51812	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51720	51813	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51721	51814	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51724,7 +51817,7 @@
51724	51817	state.addr = 839519665163075584LLU; // skip______
51725	51818	break;
51726	51819	}
51727		- case 18446744073709549393LLU: // 99999999bQ'''''''''''''''
	51820	+ case 18446744073709549391LLU: // 99999999bO'''''''''''''''
51728	51821	{
51729	51822	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
51730	51823	fprintf(stdout, "%s", " >> ");

		@@ -51734,7 +51827,7 @@
51734	51827	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51735	51828	}
51736	51829	// ACCUMULATE ARGUMENTS - END
51737		- uint64_t return_to = 18446744073709549392LLU;
	51830	+ uint64_t return_to = 18446744073709549390LLU;
51738	51831	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51739	51832	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51740	51833	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51743,7 +51836,7 @@
51743	51836	state.addr = 839519665163075584LLU; // skip______
51744	51837	break;
51745	51838	}
51746		- case 18446744073709549392LLU: // 99999999bP'''''''''''''''
	51839	+ case 18446744073709549390LLU: // 99999999bN'''''''''''''''
51747	51840	{
51748	51841
51749	51842	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -51765,7 +51858,7 @@
51765	51858	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51766	51859	}
51767	51860	// ACCUMULATE ARGUMENTS - END
51768		- uint64_t return_to = 18446744073709549391LLU;
	51861	+ uint64_t return_to = 18446744073709549389LLU;
51769	51862	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
51770	51863	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51771	51864	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51774,7 +51867,7 @@
51774	51867	state.addr = 23446349213393492LLU; // ASSERTINIT
51775	51868	break;
51776	51869	}
51777		- case 18446744073709549391LLU: // 99999999bO'''''''''''''''
	51870	+ case 18446744073709549389LLU: // 99999999bM'''''''''''''''
51778	51871	{
51779	51872	{
51780	51873	uint64_t arg = 0;

		@@ -51853,7 +51946,7 @@
51853	51946	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51854	51947	}
51855	51948	// ACCUMULATE ARGUMENTS - END
51856		- uint64_t return_to = 18446744073709549390LLU;
	51949	+ uint64_t return_to = 18446744073709549388LLU;
51857	51950	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
51858	51951	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51859	51952	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51862,7 +51955,7 @@
51862	51955	state.addr = 293363126232490310LLU; // PROCVARREF
51863	51956	break;
51864	51957	}
51865		- case 18446744073709549390LLU: // 99999999bN'''''''''''''''
	51958	+ case 18446744073709549388LLU: // 99999999bL'''''''''''''''
51866	51959	{
51867	51960	// variable u64 initialize goes out of scope
51868	51961	// emitted destructur for type u64

		@@ -51883,7 +51976,7 @@
51883	51976	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51884	51977	}
51885	51978	// ACCUMULATE ARGUMENTS - END
51886		- uint64_t return_to = 18446744073709549389LLU;
	51979	+ uint64_t return_to = 18446744073709549387LLU;
51887	51980	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
51888	51981	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51889	51982	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51892,7 +51985,7 @@
51892	51985	state.addr = 517555565476695680LLU; // assertu64_
51893	51986	break;
51894	51987	}
51895		- case 18446744073709549389LLU: // 99999999bM'''''''''''''''
	51988	+ case 18446744073709549387LLU: // 99999999bK'''''''''''''''
51896	51989	{
51897	51990	// ACCUMULATE ARGUMENTS - BEGIN
51898	51991	{

		@@ -51900,7 +51993,7 @@
51900	51993	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51901	51994	}
51902	51995	// ACCUMULATE ARGUMENTS - END
51903		- uint64_t return_to = 18446744073709549388LLU;
	51996	+ uint64_t return_to = 18446744073709549386LLU;
51904	51997	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51905	51998	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51906	51999	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51909,7 +52002,7 @@
51909	52002	state.addr = 839519665163075584LLU; // skip______
51910	52003	break;
51911	52004	}
51912		- case 18446744073709549388LLU: // 99999999bL'''''''''''''''
	52005	+ case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
51913	52006	{
51914	52007	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
51915	52008	fprintf(stdout, "%s", ";");

		@@ -51921,7 +52014,7 @@
51921	52014	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51922	52015	}
51923	52016	// ACCUMULATE ARGUMENTS - END
51924		- uint64_t return_to = 18446744073709549387LLU;
	52017	+ uint64_t return_to = 18446744073709549385LLU;
51925	52018	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51926	52019	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51927	52020	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51930,7 +52023,7 @@
51930	52023	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
51931	52024	break;
51932	52025	}
51933		- case 18446744073709549387LLU: // 99999999bK'''''''''''''''
	52026	+ case 18446744073709549385LLU: // 99999999bI'''''''''''''''
51934	52027	{
51935	52028	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
51936	52029	// variable type______ type______ goes out of scope

		@@ -51941,7 +52034,7 @@
51941	52034	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
51942	52035	}
51943	52036	// ACCUMULATE ARGUMENTS - END
51944		- uint64_t return_to = 18446744073709549386LLU;
	52037	+ uint64_t return_to = 18446744073709549384LLU;
51945	52038	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
51946	52039	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
51947	52040	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -51950,7 +52043,7 @@
51950	52043	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
51951	52044	break;
51952	52045	}
51953		- case 18446744073709549386LLU: // 99999999bJ'''''''''''''''
	52046	+ case 18446744073709549384LLU: // 99999999bH'''''''''''''''
51954	52047	{
51955	52048	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
51956	52049	// variable u64 mutable___ goes out of scope

		@@ -51962,10 +52055,10 @@
51962	52055	// variable u64 id________ goes out of scope
51963	52056	// emitted destructur for type u64
51964	52057	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
51965		- state.addr = 18446744073709549404LLU; // 99999999ba'''''''''''''''
	52058	+ state.addr = 18446744073709549402LLU; // 99999999bZ'''''''''''''''
51966	52059	break;
51967	52060	}
51968		- case 18446744073709549405LLU: // 99999999bb'''''''''''''''
	52061	+ case 18446744073709549403LLU: // 99999999b$'''''''''''''''
51969	52062	{
51970	52063
51971	52064	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 513265221985370112;

		@@ -51976,11 +52069,11 @@
51976	52069	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
51977	52070	}
51978	52071	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
51979		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549385LLU : 18446744073709549384LLU;
	52072	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549383LLU : 18446744073709549382LLU;
51980	52073	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
51981	52074	break;
51982	52075	}
51983		- case 18446744073709549385LLU: // 99999999bI'''''''''''''''
	52076	+ case 18446744073709549383LLU: // 99999999bG'''''''''''''''
51984	52077	{
51985	52078	{
51986	52079	uint64_t arg = 0;

		@@ -52007,7 +52100,7 @@
52007	52100	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52008	52101	}
52009	52102	// ACCUMULATE ARGUMENTS - END
52010		- uint64_t return_to = 18446744073709549382LLU;
	52103	+ uint64_t return_to = 18446744073709549380LLU;
52011	52104	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52012	52105	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52013	52106	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52016,7 +52109,7 @@
52016	52109	state.addr = 861504796319285248LLU; // typeu64___
52017	52110	break;
52018	52111	}
52019		- case 18446744073709549382LLU: // 99999999bF'''''''''''''''
	52112	+ case 18446744073709549380LLU: // 99999999bD'''''''''''''''
52020	52113	{
52021	52114	{
52022	52115	uint64_t arg = 0;

		@@ -52041,7 +52134,7 @@
52041	52134	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52042	52135	}
52043	52136	// ACCUMULATE ARGUMENTS - END
52044		- uint64_t return_to = 18446744073709549380LLU;
	52137	+ uint64_t return_to = 18446744073709549378LLU;
52045	52138	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52046	52139	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52047	52140	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52050,7 +52143,7 @@
52050	52143	state.addr = 861504796319285248LLU; // typeu64___
52051	52144	break;
52052	52145	}
52053		- case 18446744073709549380LLU: // 99999999bD'''''''''''''''
	52146	+ case 18446744073709549378LLU: // 99999999bB'''''''''''''''
52054	52147	{
52055	52148	{
52056	52149	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -52070,7 +52163,7 @@
52070	52163	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52071	52164	}
52072	52165	// ACCUMULATE ARGUMENTS - END
52073		- uint64_t return_to = 18446744073709549381LLU;
	52166	+ uint64_t return_to = 18446744073709549379LLU;
52074	52167	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52075	52168	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52076	52169	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52079,7 +52172,7 @@
52079	52172	state.addr = 819859607768530944LLU; // resdest___
52080	52173	break;
52081	52174	}
52082		- case 18446744073709549381LLU: // 99999999bE'''''''''''''''
	52175	+ case 18446744073709549379LLU: // 99999999bC'''''''''''''''
52083	52176	{
52084	52177	// ACCUMULATE ARGUMENTS - BEGIN
52085	52178	{

		@@ -52099,7 +52192,7 @@
52099	52192	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52100	52193	}
52101	52194	// ACCUMULATE ARGUMENTS - END
52102		- uint64_t return_to = 18446744073709549379LLU;
	52195	+ uint64_t return_to = 18446744073709549377LLU;
52103	52196	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52104	52197	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52105	52198	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52108,7 +52201,7 @@
52108	52201	state.addr = 819857494882385920LLU; // res_u64___
52109	52202	break;
52110	52203	}
52111		- case 18446744073709549379LLU: // 99999999bC'''''''''''''''
	52204	+ case 18446744073709549377LLU: // 99999999bA'''''''''''''''
52112	52205	{
52113	52206	// ACCUMULATE ARGUMENTS - BEGIN
52114	52207	{

		@@ -52116,7 +52209,7 @@
52116	52209	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52117	52210	}
52118	52211	// ACCUMULATE ARGUMENTS - END
52119		- uint64_t return_to = 18446744073709549378LLU;
	52212	+ uint64_t return_to = 18446744073709549376LLU;
52120	52213	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52121	52214	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52122	52215	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52125,7 +52218,7 @@
52125	52218	state.addr = 839519665163075584LLU; // skip______
52126	52219	break;
52127	52220	}
52128		- case 18446744073709549378LLU: // 99999999bB'''''''''''''''
	52221	+ case 18446744073709549376LLU: // 99999999b_'''''''''''''''
52129	52222	{
52130	52223	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
52131	52224	fprintf(stdout, "%s", "\n ");

		@@ -52151,7 +52244,7 @@
52151	52244	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52152	52245	}
52153	52246	// ACCUMULATE ARGUMENTS - END
52154		- uint64_t return_to = 18446744073709549377LLU;
	52247	+ uint64_t return_to = 18446744073709549375LLU;
52155	52248	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
52156	52249	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52157	52250	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52160,7 +52253,7 @@
52160	52253	state.addr = 587881357514113024LLU; // emitpar___
52161	52254	break;
52162	52255	}
52163		- case 18446744073709549377LLU: // 99999999bA'''''''''''''''
	52256	+ case 18446744073709549375LLU: // 99999999a9'''''''''''''''
52164	52257	{
52165	52258	fprintf(stdout, "%s", " = ");
52166	52259	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -52169,7 +52262,7 @@
52169	52262	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52170	52263	}
52171	52264	// ACCUMULATE ARGUMENTS - END
52172		- uint64_t return_to = 18446744073709549376LLU;
	52265	+ uint64_t return_to = 18446744073709549374LLU;
52173	52266	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52174	52267	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52175	52268	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52178,7 +52271,7 @@
52178	52271	state.addr = 839519665163075584LLU; // skip______
52179	52272	break;
52180	52273	}
52181		- case 18446744073709549376LLU: // 99999999b_'''''''''''''''
	52274	+ case 18446744073709549374LLU: // 99999999a8'''''''''''''''
52182	52275	{
52183	52276
52184	52277	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -52200,7 +52293,7 @@
52200	52293	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52201	52294	}
52202	52295	// ACCUMULATE ARGUMENTS - END
52203		- uint64_t return_to = 18446744073709549375LLU;
	52296	+ uint64_t return_to = 18446744073709549373LLU;
52204	52297	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52205	52298	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52206	52299	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52209,7 +52302,7 @@
52209	52302	state.addr = 23446349213393492LLU; // ASSERTINIT
52210	52303	break;
52211	52304	}
52212		- case 18446744073709549375LLU: // 99999999a9'''''''''''''''
	52305	+ case 18446744073709549373LLU: // 99999999a7'''''''''''''''
52213	52306	{
52214	52307	{
52215	52308	uint64_t arg = 0;

		@@ -52288,7 +52381,7 @@
52288	52381	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52289	52382	}
52290	52383	// ACCUMULATE ARGUMENTS - END
52291		- uint64_t return_to = 18446744073709549374LLU;
	52384	+ uint64_t return_to = 18446744073709549372LLU;
52292	52385	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
52293	52386	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52294	52387	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52297,7 +52390,7 @@
52297	52390	state.addr = 293363126232490310LLU; // PROCVARREF
52298	52391	break;
52299	52392	}
52300		- case 18446744073709549374LLU: // 99999999a8'''''''''''''''
	52393	+ case 18446744073709549372LLU: // 99999999a6'''''''''''''''
52301	52394	{
52302	52395	// variable u64 initialize goes out of scope
52303	52396	// emitted destructur for type u64

		@@ -52318,7 +52411,7 @@
52318	52411	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52319	52412	}
52320	52413	// ACCUMULATE ARGUMENTS - END
52321		- uint64_t return_to = 18446744073709549373LLU;
	52414	+ uint64_t return_to = 18446744073709549371LLU;
52322	52415	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
52323	52416	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52324	52417	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52327,7 +52420,7 @@
52327	52420	state.addr = 517555565476695680LLU; // assertu64_
52328	52421	break;
52329	52422	}
52330		- case 18446744073709549373LLU: // 99999999a7'''''''''''''''
	52423	+ case 18446744073709549371LLU: // 99999999a5'''''''''''''''
52331	52424	{
52332	52425	// ACCUMULATE ARGUMENTS - BEGIN
52333	52426	{

		@@ -52335,7 +52428,7 @@
52335	52428	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52336	52429	}
52337	52430	// ACCUMULATE ARGUMENTS - END
52338		- uint64_t return_to = 18446744073709549372LLU;
	52431	+ uint64_t return_to = 18446744073709549370LLU;
52339	52432	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52340	52433	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52341	52434	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52344,7 +52437,7 @@
52344	52437	state.addr = 839519665163075584LLU; // skip______
52345	52438	break;
52346	52439	}
52347		- case 18446744073709549372LLU: // 99999999a6'''''''''''''''
	52440	+ case 18446744073709549370LLU: // 99999999a4'''''''''''''''
52348	52441	{
52349	52442	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
52350	52443	fprintf(stdout, "%s", " + ");

		@@ -52354,7 +52447,7 @@
52354	52447	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52355	52448	}
52356	52449	// ACCUMULATE ARGUMENTS - END
52357		- uint64_t return_to = 18446744073709549371LLU;
	52450	+ uint64_t return_to = 18446744073709549369LLU;
52358	52451	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52359	52452	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52360	52453	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52363,7 +52456,7 @@
52363	52456	state.addr = 839519665163075584LLU; // skip______
52364	52457	break;
52365	52458	}
52366		- case 18446744073709549371LLU: // 99999999a5'''''''''''''''
	52459	+ case 18446744073709549369LLU: // 99999999a3'''''''''''''''
52367	52460	{
52368	52461
52369	52462	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -52385,7 +52478,7 @@
52385	52478	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52386	52479	}
52387	52480	// ACCUMULATE ARGUMENTS - END
52388		- uint64_t return_to = 18446744073709549370LLU;
	52481	+ uint64_t return_to = 18446744073709549368LLU;
52389	52482	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52390	52483	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52391	52484	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52394,7 +52487,7 @@
52394	52487	state.addr = 23446349213393492LLU; // ASSERTINIT
52395	52488	break;
52396	52489	}
52397		- case 18446744073709549370LLU: // 99999999a4'''''''''''''''
	52490	+ case 18446744073709549368LLU: // 99999999a2'''''''''''''''
52398	52491	{
52399	52492	{
52400	52493	uint64_t arg = 0;

		@@ -52473,7 +52566,7 @@
52473	52566	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52474	52567	}
52475	52568	// ACCUMULATE ARGUMENTS - END
52476		- uint64_t return_to = 18446744073709549369LLU;
	52569	+ uint64_t return_to = 18446744073709549367LLU;
52477	52570	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
52478	52571	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52479	52572	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52482,7 +52575,7 @@
52482	52575	state.addr = 293363126232490310LLU; // PROCVARREF
52483	52576	break;
52484	52577	}
52485		- case 18446744073709549369LLU: // 99999999a3'''''''''''''''
	52578	+ case 18446744073709549367LLU: // 99999999a1'''''''''''''''
52486	52579	{
52487	52580	// variable u64 initialize goes out of scope
52488	52581	// emitted destructur for type u64

		@@ -52503,7 +52596,7 @@
52503	52596	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52504	52597	}
52505	52598	// ACCUMULATE ARGUMENTS - END
52506		- uint64_t return_to = 18446744073709549368LLU;
	52599	+ uint64_t return_to = 18446744073709549366LLU;
52507	52600	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
52508	52601	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52509	52602	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52512,7 +52605,7 @@
52512	52605	state.addr = 517555565476695680LLU; // assertu64_
52513	52606	break;
52514	52607	}
52515		- case 18446744073709549368LLU: // 99999999a2'''''''''''''''
	52608	+ case 18446744073709549366LLU: // 99999999a0'''''''''''''''
52516	52609	{
52517	52610	// ACCUMULATE ARGUMENTS - BEGIN
52518	52611	{

		@@ -52520,7 +52613,7 @@
52520	52613	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52521	52614	}
52522	52615	// ACCUMULATE ARGUMENTS - END
52523		- uint64_t return_to = 18446744073709549367LLU;
	52616	+ uint64_t return_to = 18446744073709549365LLU;
52524	52617	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52525	52618	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52526	52619	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52529,7 +52622,7 @@
52529	52622	state.addr = 839519665163075584LLU; // skip______
52530	52623	break;
52531	52624	}
52532		- case 18446744073709549367LLU: // 99999999a1'''''''''''''''
	52625	+ case 18446744073709549365LLU: // 99999999az'''''''''''''''
52533	52626	{
52534	52627	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
52535	52628	fprintf(stdout, "%s", ";");

		@@ -52541,7 +52634,7 @@
52541	52634	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52542	52635	}
52543	52636	// ACCUMULATE ARGUMENTS - END
52544		- uint64_t return_to = 18446744073709549366LLU;
	52637	+ uint64_t return_to = 18446744073709549364LLU;
52545	52638	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52546	52639	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52547	52640	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52550,7 +52643,7 @@
52550	52643	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
52551	52644	break;
52552	52645	}
52553		- case 18446744073709549366LLU: // 99999999a0'''''''''''''''
	52646	+ case 18446744073709549364LLU: // 99999999ay'''''''''''''''
52554	52647	{
52555	52648	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
52556	52649	// variable type______ type______ goes out of scope

		@@ -52561,7 +52654,7 @@
52561	52654	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52562	52655	}
52563	52656	// ACCUMULATE ARGUMENTS - END
52564		- uint64_t return_to = 18446744073709549365LLU;
	52657	+ uint64_t return_to = 18446744073709549363LLU;
52565	52658	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52566	52659	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52567	52660	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52570,7 +52663,7 @@
52570	52663	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
52571	52664	break;
52572	52665	}
52573		- case 18446744073709549365LLU: // 99999999az'''''''''''''''
	52666	+ case 18446744073709549363LLU: // 99999999ax'''''''''''''''
52574	52667	{
52575	52668	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
52576	52669	// variable u64 mutable___ goes out of scope

		@@ -52582,10 +52675,10 @@
52582	52675	// variable u64 id________ goes out of scope
52583	52676	// emitted destructur for type u64
52584	52677	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
52585		- state.addr = 18446744073709549383LLU; // 99999999bG'''''''''''''''
	52678	+ state.addr = 18446744073709549381LLU; // 99999999bE'''''''''''''''
52586	52679	break;
52587	52680	}
52588		- case 18446744073709549384LLU: // 99999999bH'''''''''''''''
	52681	+ case 18446744073709549382LLU: // 99999999bF'''''''''''''''
52589	52682	{
52590	52683
52591	52684	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 842300673667104768;

		@@ -52596,11 +52689,11 @@
52596	52689	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
52597	52690	}
52598	52691	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
52599		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549364LLU : 18446744073709549363LLU;
	52692	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549362LLU : 18446744073709549361LLU;
52600	52693	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
52601	52694	break;
52602	52695	}
52603		- case 18446744073709549364LLU: // 99999999ay'''''''''''''''
	52696	+ case 18446744073709549362LLU: // 99999999aw'''''''''''''''
52604	52697	{
52605	52698	{
52606	52699	uint64_t arg = 0;

		@@ -52627,7 +52720,7 @@
52627	52720	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52628	52721	}
52629	52722	// ACCUMULATE ARGUMENTS - END
52630		- uint64_t return_to = 18446744073709549361LLU;
	52723	+ uint64_t return_to = 18446744073709549359LLU;
52631	52724	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52632	52725	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52633	52726	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52636,7 +52729,7 @@
52636	52729	state.addr = 861504796319285248LLU; // typeu64___
52637	52730	break;
52638	52731	}
52639		- case 18446744073709549361LLU: // 99999999av'''''''''''''''
	52732	+ case 18446744073709549359LLU: // 99999999at'''''''''''''''
52640	52733	{
52641	52734	{
52642	52735	uint64_t arg = 0;

		@@ -52661,7 +52754,7 @@
52661	52754	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52662	52755	}
52663	52756	// ACCUMULATE ARGUMENTS - END
52664		- uint64_t return_to = 18446744073709549359LLU;
	52757	+ uint64_t return_to = 18446744073709549357LLU;
52665	52758	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52666	52759	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52667	52760	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52670,7 +52763,7 @@
52670	52763	state.addr = 861504796319285248LLU; // typeu64___
52671	52764	break;
52672	52765	}
52673		- case 18446744073709549359LLU: // 99999999at'''''''''''''''
	52766	+ case 18446744073709549357LLU: // 99999999ar'''''''''''''''
52674	52767	{
52675	52768	{
52676	52769	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -52690,7 +52783,7 @@
52690	52783	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52691	52784	}
52692	52785	// ACCUMULATE ARGUMENTS - END
52693		- uint64_t return_to = 18446744073709549360LLU;
	52786	+ uint64_t return_to = 18446744073709549358LLU;
52694	52787	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52695	52788	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52696	52789	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52699,7 +52792,7 @@
52699	52792	state.addr = 819859607768530944LLU; // resdest___
52700	52793	break;
52701	52794	}
52702		- case 18446744073709549360LLU: // 99999999au'''''''''''''''
	52795	+ case 18446744073709549358LLU: // 99999999as'''''''''''''''
52703	52796	{
52704	52797	// ACCUMULATE ARGUMENTS - BEGIN
52705	52798	{

		@@ -52719,7 +52812,7 @@
52719	52812	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52720	52813	}
52721	52814	// ACCUMULATE ARGUMENTS - END
52722		- uint64_t return_to = 18446744073709549358LLU;
	52815	+ uint64_t return_to = 18446744073709549356LLU;
52723	52816	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52724	52817	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52725	52818	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52728,7 +52821,7 @@
52728	52821	state.addr = 819857494882385920LLU; // res_u64___
52729	52822	break;
52730	52823	}
52731		- case 18446744073709549358LLU: // 99999999as'''''''''''''''
	52824	+ case 18446744073709549356LLU: // 99999999aq'''''''''''''''
52732	52825	{
52733	52826	// ACCUMULATE ARGUMENTS - BEGIN
52734	52827	{

		@@ -52736,7 +52829,7 @@
52736	52829	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52737	52830	}
52738	52831	// ACCUMULATE ARGUMENTS - END
52739		- uint64_t return_to = 18446744073709549357LLU;
	52832	+ uint64_t return_to = 18446744073709549355LLU;
52740	52833	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52741	52834	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52742	52835	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52745,7 +52838,7 @@
52745	52838	state.addr = 839519665163075584LLU; // skip______
52746	52839	break;
52747	52840	}
52748		- case 18446744073709549357LLU: // 99999999ar'''''''''''''''
	52841	+ case 18446744073709549355LLU: // 99999999ap'''''''''''''''
52749	52842	{
52750	52843	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
52751	52844	fprintf(stdout, "%s", "\n ");

		@@ -52771,7 +52864,7 @@
52771	52864	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52772	52865	}
52773	52866	// ACCUMULATE ARGUMENTS - END
52774		- uint64_t return_to = 18446744073709549356LLU;
	52867	+ uint64_t return_to = 18446744073709549354LLU;
52775	52868	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
52776	52869	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52777	52870	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52780,7 +52873,7 @@
52780	52873	state.addr = 587881357514113024LLU; // emitpar___
52781	52874	break;
52782	52875	}
52783		- case 18446744073709549356LLU: // 99999999aq'''''''''''''''
	52876	+ case 18446744073709549354LLU: // 99999999ao'''''''''''''''
52784	52877	{
52785	52878	fprintf(stdout, "%s", " = ");
52786	52879	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -52789,7 +52882,7 @@
52789	52882	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52790	52883	}
52791	52884	// ACCUMULATE ARGUMENTS - END
52792		- uint64_t return_to = 18446744073709549355LLU;
	52885	+ uint64_t return_to = 18446744073709549353LLU;
52793	52886	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52794	52887	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52795	52888	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52798,7 +52891,7 @@
52798	52891	state.addr = 839519665163075584LLU; // skip______
52799	52892	break;
52800	52893	}
52801		- case 18446744073709549355LLU: // 99999999ap'''''''''''''''
	52894	+ case 18446744073709549353LLU: // 99999999an'''''''''''''''
52802	52895	{
52803	52896
52804	52897	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -52820,7 +52913,7 @@
52820	52913	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52821	52914	}
52822	52915	// ACCUMULATE ARGUMENTS - END
52823		- uint64_t return_to = 18446744073709549354LLU;
	52916	+ uint64_t return_to = 18446744073709549352LLU;
52824	52917	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
52825	52918	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52826	52919	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52829,7 +52922,7 @@
52829	52922	state.addr = 23446349213393492LLU; // ASSERTINIT
52830	52923	break;
52831	52924	}
52832		- case 18446744073709549354LLU: // 99999999ao'''''''''''''''
	52925	+ case 18446744073709549352LLU: // 99999999am'''''''''''''''
52833	52926	{
52834	52927	{
52835	52928	uint64_t arg = 0;

		@@ -52908,7 +53001,7 @@
52908	53001	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52909	53002	}
52910	53003	// ACCUMULATE ARGUMENTS - END
52911		- uint64_t return_to = 18446744073709549353LLU;
	53004	+ uint64_t return_to = 18446744073709549351LLU;
52912	53005	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
52913	53006	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52914	53007	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52917,7 +53010,7 @@
52917	53010	state.addr = 293363126232490310LLU; // PROCVARREF
52918	53011	break;
52919	53012	}
52920		- case 18446744073709549353LLU: // 99999999an'''''''''''''''
	53013	+ case 18446744073709549351LLU: // 99999999al'''''''''''''''
52921	53014	{
52922	53015	// variable u64 initialize goes out of scope
52923	53016	// emitted destructur for type u64

		@@ -52938,7 +53031,7 @@
52938	53031	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52939	53032	}
52940	53033	// ACCUMULATE ARGUMENTS - END
52941		- uint64_t return_to = 18446744073709549352LLU;
	53034	+ uint64_t return_to = 18446744073709549350LLU;
52942	53035	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
52943	53036	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52944	53037	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52947,7 +53040,7 @@
52947	53040	state.addr = 517555565476695680LLU; // assertu64_
52948	53041	break;
52949	53042	}
52950		- case 18446744073709549352LLU: // 99999999am'''''''''''''''
	53043	+ case 18446744073709549350LLU: // 99999999ak'''''''''''''''
52951	53044	{
52952	53045	// ACCUMULATE ARGUMENTS - BEGIN
52953	53046	{

		@@ -52955,7 +53048,7 @@
52955	53048	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52956	53049	}
52957	53050	// ACCUMULATE ARGUMENTS - END
52958		- uint64_t return_to = 18446744073709549351LLU;
	53051	+ uint64_t return_to = 18446744073709549349LLU;
52959	53052	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52960	53053	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52961	53054	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52964,7 +53057,7 @@
52964	53057	state.addr = 839519665163075584LLU; // skip______
52965	53058	break;
52966	53059	}
52967		- case 18446744073709549351LLU: // 99999999al'''''''''''''''
	53060	+ case 18446744073709549349LLU: // 99999999aj'''''''''''''''
52968	53061	{
52969	53062	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
52970	53063	fprintf(stdout, "%s", " - ");

		@@ -52974,7 +53067,7 @@
52974	53067	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
52975	53068	}
52976	53069	// ACCUMULATE ARGUMENTS - END
52977		- uint64_t return_to = 18446744073709549350LLU;
	53070	+ uint64_t return_to = 18446744073709549348LLU;
52978	53071	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
52979	53072	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
52980	53073	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -52983,7 +53076,7 @@
52983	53076	state.addr = 839519665163075584LLU; // skip______
52984	53077	break;
52985	53078	}
52986		- case 18446744073709549350LLU: // 99999999ak'''''''''''''''
	53079	+ case 18446744073709549348LLU: // 99999999ai'''''''''''''''
52987	53080	{
52988	53081
52989	53082	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -53005,7 +53098,7 @@
53005	53098	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53006	53099	}
53007	53100	// ACCUMULATE ARGUMENTS - END
53008		- uint64_t return_to = 18446744073709549349LLU;
	53101	+ uint64_t return_to = 18446744073709549347LLU;
53009	53102	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53010	53103	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53011	53104	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53014,7 +53107,7 @@
53014	53107	state.addr = 23446349213393492LLU; // ASSERTINIT
53015	53108	break;
53016	53109	}
53017		- case 18446744073709549349LLU: // 99999999aj'''''''''''''''
	53110	+ case 18446744073709549347LLU: // 99999999ah'''''''''''''''
53018	53111	{
53019	53112	{
53020	53113	uint64_t arg = 0;

		@@ -53093,7 +53186,7 @@
53093	53186	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53094	53187	}
53095	53188	// ACCUMULATE ARGUMENTS - END
53096		- uint64_t return_to = 18446744073709549348LLU;
	53189	+ uint64_t return_to = 18446744073709549346LLU;
53097	53190	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
53098	53191	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53099	53192	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53102,7 +53195,7 @@
53102	53195	state.addr = 293363126232490310LLU; // PROCVARREF
53103	53196	break;
53104	53197	}
53105		- case 18446744073709549348LLU: // 99999999ai'''''''''''''''
	53198	+ case 18446744073709549346LLU: // 99999999ag'''''''''''''''
53106	53199	{
53107	53200	// variable u64 initialize goes out of scope
53108	53201	// emitted destructur for type u64

		@@ -53123,7 +53216,7 @@
53123	53216	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53124	53217	}
53125	53218	// ACCUMULATE ARGUMENTS - END
53126		- uint64_t return_to = 18446744073709549347LLU;
	53219	+ uint64_t return_to = 18446744073709549345LLU;
53127	53220	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53128	53221	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53129	53222	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53132,7 +53225,7 @@
53132	53225	state.addr = 517555565476695680LLU; // assertu64_
53133	53226	break;
53134	53227	}
53135		- case 18446744073709549347LLU: // 99999999ah'''''''''''''''
	53228	+ case 18446744073709549345LLU: // 99999999af'''''''''''''''
53136	53229	{
53137	53230	// ACCUMULATE ARGUMENTS - BEGIN
53138	53231	{

		@@ -53140,7 +53233,7 @@
53140	53233	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53141	53234	}
53142	53235	// ACCUMULATE ARGUMENTS - END
53143		- uint64_t return_to = 18446744073709549346LLU;
	53236	+ uint64_t return_to = 18446744073709549344LLU;
53144	53237	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53145	53238	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53146	53239	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53149,7 +53242,7 @@
53149	53242	state.addr = 839519665163075584LLU; // skip______
53150	53243	break;
53151	53244	}
53152		- case 18446744073709549346LLU: // 99999999ag'''''''''''''''
	53245	+ case 18446744073709549344LLU: // 99999999ae'''''''''''''''
53153	53246	{
53154	53247	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
53155	53248	fprintf(stdout, "%s", ";");

		@@ -53161,7 +53254,7 @@
53161	53254	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53162	53255	}
53163	53256	// ACCUMULATE ARGUMENTS - END
53164		- uint64_t return_to = 18446744073709549345LLU;
	53257	+ uint64_t return_to = 18446744073709549343LLU;
53165	53258	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53166	53259	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53167	53260	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53170,7 +53263,7 @@
53170	53263	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
53171	53264	break;
53172	53265	}
53173		- case 18446744073709549345LLU: // 99999999af'''''''''''''''
	53266	+ case 18446744073709549343LLU: // 99999999ad'''''''''''''''
53174	53267	{
53175	53268	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
53176	53269	// variable type______ type______ goes out of scope

		@@ -53181,7 +53274,7 @@
53181	53274	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53182	53275	}
53183	53276	// ACCUMULATE ARGUMENTS - END
53184		- uint64_t return_to = 18446744073709549344LLU;
	53277	+ uint64_t return_to = 18446744073709549342LLU;
53185	53278	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53186	53279	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53187	53280	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53190,7 +53283,7 @@
53190	53283	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
53191	53284	break;
53192	53285	}
53193		- case 18446744073709549344LLU: // 99999999ae'''''''''''''''
	53286	+ case 18446744073709549342LLU: // 99999999ac'''''''''''''''
53194	53287	{
53195	53288	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
53196	53289	// variable u64 mutable___ goes out of scope

		@@ -53202,10 +53295,10 @@
53202	53295	// variable u64 id________ goes out of scope
53203	53296	// emitted destructur for type u64
53204	53297	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
53205		- state.addr = 18446744073709549362LLU; // 99999999aw'''''''''''''''
	53298	+ state.addr = 18446744073709549360LLU; // 99999999au'''''''''''''''
53206	53299	break;
53207	53300	}
53208		- case 18446744073709549363LLU: // 99999999ax'''''''''''''''
	53301	+ case 18446744073709549361LLU: // 99999999av'''''''''''''''
53209	53302	{
53210	53303
53211	53304	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 734258263075323904;

		@@ -53216,11 +53309,11 @@
53216	53309	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
53217	53310	}
53218	53311	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53219		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549343LLU : 18446744073709549342LLU;
	53312	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549341LLU : 18446744073709549340LLU;
53220	53313	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
53221	53314	break;
53222	53315	}
53223		- case 18446744073709549343LLU: // 99999999ad'''''''''''''''
	53316	+ case 18446744073709549341LLU: // 99999999ab'''''''''''''''
53224	53317	{
53225	53318	{
53226	53319	uint64_t arg = 0;

		@@ -53247,7 +53340,7 @@
53247	53340	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53248	53341	}
53249	53342	// ACCUMULATE ARGUMENTS - END
53250		- uint64_t return_to = 18446744073709549340LLU;
	53343	+ uint64_t return_to = 18446744073709549338LLU;
53251	53344	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53252	53345	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53253	53346	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53256,7 +53349,7 @@
53256	53349	state.addr = 861504796319285248LLU; // typeu64___
53257	53350	break;
53258	53351	}
53259		- case 18446744073709549340LLU: // 99999999aa'''''''''''''''
	53352	+ case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
53260	53353	{
53261	53354	{
53262	53355	uint64_t arg = 0;

		@@ -53281,7 +53374,7 @@
53281	53374	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53282	53375	}
53283	53376	// ACCUMULATE ARGUMENTS - END
53284		- uint64_t return_to = 18446744073709549338LLU;
	53377	+ uint64_t return_to = 18446744073709549336LLU;
53285	53378	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53286	53379	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53287	53380	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53290,7 +53383,7 @@
53290	53383	state.addr = 861504796319285248LLU; // typeu64___
53291	53384	break;
53292	53385	}
53293		- case 18446744073709549338LLU: // 99999999aZ'''''''''''''''
	53386	+ case 18446744073709549336LLU: // 99999999aX'''''''''''''''
53294	53387	{
53295	53388	{
53296	53389	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -53310,7 +53403,7 @@
53310	53403	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53311	53404	}
53312	53405	// ACCUMULATE ARGUMENTS - END
53313		- uint64_t return_to = 18446744073709549339LLU;
	53406	+ uint64_t return_to = 18446744073709549337LLU;
53314	53407	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53315	53408	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53316	53409	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53319,7 +53412,7 @@
53319	53412	state.addr = 819859607768530944LLU; // resdest___
53320	53413	break;
53321	53414	}
53322		- case 18446744073709549339LLU: // 99999999a$'''''''''''''''
	53415	+ case 18446744073709549337LLU: // 99999999aY'''''''''''''''
53323	53416	{
53324	53417	// ACCUMULATE ARGUMENTS - BEGIN
53325	53418	{

		@@ -53339,7 +53432,7 @@
53339	53432	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53340	53433	}
53341	53434	// ACCUMULATE ARGUMENTS - END
53342		- uint64_t return_to = 18446744073709549337LLU;
	53435	+ uint64_t return_to = 18446744073709549335LLU;
53343	53436	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53344	53437	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53345	53438	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53348,7 +53441,7 @@
53348	53441	state.addr = 819857494882385920LLU; // res_u64___
53349	53442	break;
53350	53443	}
53351		- case 18446744073709549337LLU: // 99999999aY'''''''''''''''
	53444	+ case 18446744073709549335LLU: // 99999999aW'''''''''''''''
53352	53445	{
53353	53446	// ACCUMULATE ARGUMENTS - BEGIN
53354	53447	{

		@@ -53356,7 +53449,7 @@
53356	53449	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53357	53450	}
53358	53451	// ACCUMULATE ARGUMENTS - END
53359		- uint64_t return_to = 18446744073709549336LLU;
	53452	+ uint64_t return_to = 18446744073709549334LLU;
53360	53453	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53361	53454	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53362	53455	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53365,7 +53458,7 @@
53365	53458	state.addr = 839519665163075584LLU; // skip______
53366	53459	break;
53367	53460	}
53368		- case 18446744073709549336LLU: // 99999999aX'''''''''''''''
	53461	+ case 18446744073709549334LLU: // 99999999aV'''''''''''''''
53369	53462	{
53370	53463	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
53371	53464	fprintf(stdout, "%s", "\n ");

		@@ -53391,7 +53484,7 @@
53391	53484	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53392	53485	}
53393	53486	// ACCUMULATE ARGUMENTS - END
53394		- uint64_t return_to = 18446744073709549335LLU;
	53487	+ uint64_t return_to = 18446744073709549333LLU;
53395	53488	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
53396	53489	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53397	53490	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53400,7 +53493,7 @@
53400	53493	state.addr = 587881357514113024LLU; // emitpar___
53401	53494	break;
53402	53495	}
53403		- case 18446744073709549335LLU: // 99999999aW'''''''''''''''
	53496	+ case 18446744073709549333LLU: // 99999999aU'''''''''''''''
53404	53497	{
53405	53498	fprintf(stdout, "%s", " = ");
53406	53499	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -53409,7 +53502,7 @@
53409	53502	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53410	53503	}
53411	53504	// ACCUMULATE ARGUMENTS - END
53412		- uint64_t return_to = 18446744073709549334LLU;
	53505	+ uint64_t return_to = 18446744073709549332LLU;
53413	53506	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53414	53507	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53415	53508	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53418,7 +53511,7 @@
53418	53511	state.addr = 839519665163075584LLU; // skip______
53419	53512	break;
53420	53513	}
53421		- case 18446744073709549334LLU: // 99999999aV'''''''''''''''
	53514	+ case 18446744073709549332LLU: // 99999999aT'''''''''''''''
53422	53515	{
53423	53516
53424	53517	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -53440,7 +53533,7 @@
53440	53533	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53441	53534	}
53442	53535	// ACCUMULATE ARGUMENTS - END
53443		- uint64_t return_to = 18446744073709549333LLU;
	53536	+ uint64_t return_to = 18446744073709549331LLU;
53444	53537	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53445	53538	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53446	53539	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53449,7 +53542,7 @@
53449	53542	state.addr = 23446349213393492LLU; // ASSERTINIT
53450	53543	break;
53451	53544	}
53452		- case 18446744073709549333LLU: // 99999999aU'''''''''''''''
	53545	+ case 18446744073709549331LLU: // 99999999aS'''''''''''''''
53453	53546	{
53454	53547	{
53455	53548	uint64_t arg = 0;

		@@ -53528,7 +53621,7 @@
53528	53621	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53529	53622	}
53530	53623	// ACCUMULATE ARGUMENTS - END
53531		- uint64_t return_to = 18446744073709549332LLU;
	53624	+ uint64_t return_to = 18446744073709549330LLU;
53532	53625	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
53533	53626	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53534	53627	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53537,7 +53630,7 @@
53537	53630	state.addr = 293363126232490310LLU; // PROCVARREF
53538	53631	break;
53539	53632	}
53540		- case 18446744073709549332LLU: // 99999999aT'''''''''''''''
	53633	+ case 18446744073709549330LLU: // 99999999aR'''''''''''''''
53541	53634	{
53542	53635	// variable u64 initialize goes out of scope
53543	53636	// emitted destructur for type u64

		@@ -53558,7 +53651,7 @@
53558	53651	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53559	53652	}
53560	53653	// ACCUMULATE ARGUMENTS - END
53561		- uint64_t return_to = 18446744073709549331LLU;
	53654	+ uint64_t return_to = 18446744073709549329LLU;
53562	53655	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53563	53656	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53564	53657	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53567,7 +53660,7 @@
53567	53660	state.addr = 517555565476695680LLU; // assertu64_
53568	53661	break;
53569	53662	}
53570		- case 18446744073709549331LLU: // 99999999aS'''''''''''''''
	53663	+ case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
53571	53664	{
53572	53665	// ACCUMULATE ARGUMENTS - BEGIN
53573	53666	{

		@@ -53575,7 +53668,7 @@
53575	53668	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53576	53669	}
53577	53670	// ACCUMULATE ARGUMENTS - END
53578		- uint64_t return_to = 18446744073709549330LLU;
	53671	+ uint64_t return_to = 18446744073709549328LLU;
53579	53672	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53580	53673	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53581	53674	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53584,7 +53677,7 @@
53584	53677	state.addr = 839519665163075584LLU; // skip______
53585	53678	break;
53586	53679	}
53587		- case 18446744073709549330LLU: // 99999999aR'''''''''''''''
	53680	+ case 18446744073709549328LLU: // 99999999aP'''''''''''''''
53588	53681	{
53589	53682	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
53590	53683	fprintf(stdout, "%s", " * ");

		@@ -53594,7 +53687,7 @@
53594	53687	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53595	53688	}
53596	53689	// ACCUMULATE ARGUMENTS - END
53597		- uint64_t return_to = 18446744073709549329LLU;
	53690	+ uint64_t return_to = 18446744073709549327LLU;
53598	53691	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53599	53692	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53600	53693	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53603,7 +53696,7 @@
53603	53696	state.addr = 839519665163075584LLU; // skip______
53604	53697	break;
53605	53698	}
53606		- case 18446744073709549329LLU: // 99999999aQ'''''''''''''''
	53699	+ case 18446744073709549327LLU: // 99999999aO'''''''''''''''
53607	53700	{
53608	53701
53609	53702	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -53625,7 +53718,7 @@
53625	53718	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53626	53719	}
53627	53720	// ACCUMULATE ARGUMENTS - END
53628		- uint64_t return_to = 18446744073709549328LLU;
	53721	+ uint64_t return_to = 18446744073709549326LLU;
53629	53722	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53630	53723	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53631	53724	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53634,7 +53727,7 @@
53634	53727	state.addr = 23446349213393492LLU; // ASSERTINIT
53635	53728	break;
53636	53729	}
53637		- case 18446744073709549328LLU: // 99999999aP'''''''''''''''
	53730	+ case 18446744073709549326LLU: // 99999999aN'''''''''''''''
53638	53731	{
53639	53732	{
53640	53733	uint64_t arg = 0;

		@@ -53713,7 +53806,7 @@
53713	53806	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53714	53807	}
53715	53808	// ACCUMULATE ARGUMENTS - END
53716		- uint64_t return_to = 18446744073709549327LLU;
	53809	+ uint64_t return_to = 18446744073709549325LLU;
53717	53810	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
53718	53811	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53719	53812	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53722,7 +53815,7 @@
53722	53815	state.addr = 293363126232490310LLU; // PROCVARREF
53723	53816	break;
53724	53817	}
53725		- case 18446744073709549327LLU: // 99999999aO'''''''''''''''
	53818	+ case 18446744073709549325LLU: // 99999999aM'''''''''''''''
53726	53819	{
53727	53820	// variable u64 initialize goes out of scope
53728	53821	// emitted destructur for type u64

		@@ -53743,7 +53836,7 @@
53743	53836	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53744	53837	}
53745	53838	// ACCUMULATE ARGUMENTS - END
53746		- uint64_t return_to = 18446744073709549326LLU;
	53839	+ uint64_t return_to = 18446744073709549324LLU;
53747	53840	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
53748	53841	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53749	53842	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53752,7 +53845,7 @@
53752	53845	state.addr = 517555565476695680LLU; // assertu64_
53753	53846	break;
53754	53847	}
53755		- case 18446744073709549326LLU: // 99999999aN'''''''''''''''
	53848	+ case 18446744073709549324LLU: // 99999999aL'''''''''''''''
53756	53849	{
53757	53850	// ACCUMULATE ARGUMENTS - BEGIN
53758	53851	{

		@@ -53760,7 +53853,7 @@
53760	53853	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53761	53854	}
53762	53855	// ACCUMULATE ARGUMENTS - END
53763		- uint64_t return_to = 18446744073709549325LLU;
	53856	+ uint64_t return_to = 18446744073709549323LLU;
53764	53857	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53765	53858	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53766	53859	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53769,7 +53862,7 @@
53769	53862	state.addr = 839519665163075584LLU; // skip______
53770	53863	break;
53771	53864	}
53772		- case 18446744073709549325LLU: // 99999999aM'''''''''''''''
	53865	+ case 18446744073709549323LLU: // 99999999aK'''''''''''''''
53773	53866	{
53774	53867	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
53775	53868	fprintf(stdout, "%s", ";");

		@@ -53781,7 +53874,7 @@
53781	53874	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53782	53875	}
53783	53876	// ACCUMULATE ARGUMENTS - END
53784		- uint64_t return_to = 18446744073709549324LLU;
	53877	+ uint64_t return_to = 18446744073709549322LLU;
53785	53878	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53786	53879	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53787	53880	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53790,7 +53883,7 @@
53790	53883	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
53791	53884	break;
53792	53885	}
53793		- case 18446744073709549324LLU: // 99999999aL'''''''''''''''
	53886	+ case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
53794	53887	{
53795	53888	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
53796	53889	// variable type______ type______ goes out of scope

		@@ -53801,7 +53894,7 @@
53801	53894	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53802	53895	}
53803	53896	// ACCUMULATE ARGUMENTS - END
53804		- uint64_t return_to = 18446744073709549323LLU;
	53897	+ uint64_t return_to = 18446744073709549321LLU;
53805	53898	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53806	53899	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53807	53900	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53810,7 +53903,7 @@
53810	53903	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
53811	53904	break;
53812	53905	}
53813		- case 18446744073709549323LLU: // 99999999aK'''''''''''''''
	53906	+ case 18446744073709549321LLU: // 99999999aI'''''''''''''''
53814	53907	{
53815	53908	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
53816	53909	// variable u64 mutable___ goes out of scope

		@@ -53822,10 +53915,10 @@
53822	53915	// variable u64 id________ goes out of scope
53823	53916	// emitted destructur for type u64
53824	53917	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
53825		- state.addr = 18446744073709549341LLU; // 99999999ab'''''''''''''''
	53918	+ state.addr = 18446744073709549339LLU; // 99999999a$'''''''''''''''
53826	53919	break;
53827	53920	}
53828		- case 18446744073709549342LLU: // 99999999ac'''''''''''''''
	53921	+ case 18446744073709549340LLU: // 99999999aa'''''''''''''''
53829	53922	{
53830	53923
53831	53924	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 568794957234569216;

		@@ -53836,11 +53929,11 @@
53836	53929	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
53837	53930	}
53838	53931	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
53839		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549322LLU : 18446744073709549321LLU;
	53932	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549320LLU : 18446744073709549319LLU;
53840	53933	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
53841	53934	break;
53842	53935	}
53843		- case 18446744073709549322LLU: // 99999999aJ'''''''''''''''
	53936	+ case 18446744073709549320LLU: // 99999999aH'''''''''''''''
53844	53937	{
53845	53938	{
53846	53939	uint64_t arg = 0;

		@@ -53867,7 +53960,7 @@
53867	53960	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53868	53961	}
53869	53962	// ACCUMULATE ARGUMENTS - END
53870		- uint64_t return_to = 18446744073709549319LLU;
	53963	+ uint64_t return_to = 18446744073709549317LLU;
53871	53964	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53872	53965	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53873	53966	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53876,7 +53969,7 @@
53876	53969	state.addr = 861504796319285248LLU; // typeu64___
53877	53970	break;
53878	53971	}
53879		- case 18446744073709549319LLU: // 99999999aG'''''''''''''''
	53972	+ case 18446744073709549317LLU: // 99999999aE'''''''''''''''
53880	53973	{
53881	53974	{
53882	53975	uint64_t arg = 0;

		@@ -53901,7 +53994,7 @@
53901	53994	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53902	53995	}
53903	53996	// ACCUMULATE ARGUMENTS - END
53904		- uint64_t return_to = 18446744073709549317LLU;
	53997	+ uint64_t return_to = 18446744073709549315LLU;
53905	53998	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53906	53999	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53907	54000	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53910,7 +54003,7 @@
53910	54003	state.addr = 861504796319285248LLU; // typeu64___
53911	54004	break;
53912	54005	}
53913		- case 18446744073709549317LLU: // 99999999aE'''''''''''''''
	54006	+ case 18446744073709549315LLU: // 99999999aC'''''''''''''''
53914	54007	{
53915	54008	{
53916	54009	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -53930,7 +54023,7 @@
53930	54023	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53931	54024	}
53932	54025	// ACCUMULATE ARGUMENTS - END
53933		- uint64_t return_to = 18446744073709549318LLU;
	54026	+ uint64_t return_to = 18446744073709549316LLU;
53934	54027	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53935	54028	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53936	54029	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53939,7 +54032,7 @@
53939	54032	state.addr = 819859607768530944LLU; // resdest___
53940	54033	break;
53941	54034	}
53942		- case 18446744073709549318LLU: // 99999999aF'''''''''''''''
	54035	+ case 18446744073709549316LLU: // 99999999aD'''''''''''''''
53943	54036	{
53944	54037	// ACCUMULATE ARGUMENTS - BEGIN
53945	54038	{

		@@ -53959,7 +54052,7 @@
53959	54052	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53960	54053	}
53961	54054	// ACCUMULATE ARGUMENTS - END
53962		- uint64_t return_to = 18446744073709549316LLU;
	54055	+ uint64_t return_to = 18446744073709549314LLU;
53963	54056	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
53964	54057	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53965	54058	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53968,7 +54061,7 @@
53968	54061	state.addr = 819857494882385920LLU; // res_u64___
53969	54062	break;
53970	54063	}
53971		- case 18446744073709549316LLU: // 99999999aD'''''''''''''''
	54064	+ case 18446744073709549314LLU: // 99999999aB'''''''''''''''
53972	54065	{
53973	54066	// ACCUMULATE ARGUMENTS - BEGIN
53974	54067	{

		@@ -53976,7 +54069,7 @@
53976	54069	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
53977	54070	}
53978	54071	// ACCUMULATE ARGUMENTS - END
53979		- uint64_t return_to = 18446744073709549315LLU;
	54072	+ uint64_t return_to = 18446744073709549313LLU;
53980	54073	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
53981	54074	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
53982	54075	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -53985,7 +54078,7 @@
53985	54078	state.addr = 839519665163075584LLU; // skip______
53986	54079	break;
53987	54080	}
53988		- case 18446744073709549315LLU: // 99999999aC'''''''''''''''
	54081	+ case 18446744073709549313LLU: // 99999999aA'''''''''''''''
53989	54082	{
53990	54083	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
53991	54084	fprintf(stdout, "%s", "\n ");

		@@ -54011,7 +54104,7 @@
54011	54104	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54012	54105	}
54013	54106	// ACCUMULATE ARGUMENTS - END
54014		- uint64_t return_to = 18446744073709549314LLU;
	54107	+ uint64_t return_to = 18446744073709549312LLU;
54015	54108	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
54016	54109	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54017	54110	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54020,7 +54113,7 @@
54020	54113	state.addr = 587881357514113024LLU; // emitpar___
54021	54114	break;
54022	54115	}
54023		- case 18446744073709549314LLU: // 99999999aB'''''''''''''''
	54116	+ case 18446744073709549312LLU: // 99999999a_'''''''''''''''
54024	54117	{
54025	54118	fprintf(stdout, "%s", " = ");
54026	54119	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54029,7 +54122,7 @@
54029	54122	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54030	54123	}
54031	54124	// ACCUMULATE ARGUMENTS - END
54032		- uint64_t return_to = 18446744073709549313LLU;
	54125	+ uint64_t return_to = 18446744073709549311LLU;
54033	54126	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54034	54127	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54035	54128	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54038,7 +54131,7 @@
54038	54131	state.addr = 839519665163075584LLU; // skip______
54039	54132	break;
54040	54133	}
54041		- case 18446744073709549313LLU: // 99999999aA'''''''''''''''
	54134	+ case 18446744073709549311LLU: // 99999999$9'''''''''''''''
54042	54135	{
54043	54136
54044	54137	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -54060,7 +54153,7 @@
54060	54153	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54061	54154	}
54062	54155	// ACCUMULATE ARGUMENTS - END
54063		- uint64_t return_to = 18446744073709549312LLU;
	54156	+ uint64_t return_to = 18446744073709549310LLU;
54064	54157	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54065	54158	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54066	54159	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54069,7 +54162,7 @@
54069	54162	state.addr = 23446349213393492LLU; // ASSERTINIT
54070	54163	break;
54071	54164	}
54072		- case 18446744073709549312LLU: // 99999999a_'''''''''''''''
	54165	+ case 18446744073709549310LLU: // 99999999$8'''''''''''''''
54073	54166	{
54074	54167	{
54075	54168	uint64_t arg = 0;

		@@ -54148,7 +54241,7 @@
54148	54241	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54149	54242	}
54150	54243	// ACCUMULATE ARGUMENTS - END
54151		- uint64_t return_to = 18446744073709549311LLU;
	54244	+ uint64_t return_to = 18446744073709549309LLU;
54152	54245	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
54153	54246	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54154	54247	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54157,7 +54250,7 @@
54157	54250	state.addr = 293363126232490310LLU; // PROCVARREF
54158	54251	break;
54159	54252	}
54160		- case 18446744073709549311LLU: // 99999999$9'''''''''''''''
	54253	+ case 18446744073709549309LLU: // 99999999$7'''''''''''''''
54161	54254	{
54162	54255	// variable u64 initialize goes out of scope
54163	54256	// emitted destructur for type u64

		@@ -54178,7 +54271,7 @@
54178	54271	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54179	54272	}
54180	54273	// ACCUMULATE ARGUMENTS - END
54181		- uint64_t return_to = 18446744073709549310LLU;
	54274	+ uint64_t return_to = 18446744073709549308LLU;
54182	54275	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
54183	54276	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54184	54277	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54187,7 +54280,7 @@
54187	54280	state.addr = 517555565476695680LLU; // assertu64_
54188	54281	break;
54189	54282	}
54190		- case 18446744073709549310LLU: // 99999999$8'''''''''''''''
	54283	+ case 18446744073709549308LLU: // 99999999$6'''''''''''''''
54191	54284	{
54192	54285	// ACCUMULATE ARGUMENTS - BEGIN
54193	54286	{

		@@ -54195,7 +54288,7 @@
54195	54288	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54196	54289	}
54197	54290	// ACCUMULATE ARGUMENTS - END
54198		- uint64_t return_to = 18446744073709549309LLU;
	54291	+ uint64_t return_to = 18446744073709549307LLU;
54199	54292	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54200	54293	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54201	54294	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54204,7 +54297,7 @@
54204	54297	state.addr = 839519665163075584LLU; // skip______
54205	54298	break;
54206	54299	}
54207		- case 18446744073709549309LLU: // 99999999$7'''''''''''''''
	54300	+ case 18446744073709549307LLU: // 99999999$5'''''''''''''''
54208	54301	{
54209	54302	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
54210	54303	fprintf(stdout, "%s", " / ");

		@@ -54214,7 +54307,7 @@
54214	54307	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54215	54308	}
54216	54309	// ACCUMULATE ARGUMENTS - END
54217		- uint64_t return_to = 18446744073709549308LLU;
	54310	+ uint64_t return_to = 18446744073709549306LLU;
54218	54311	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54219	54312	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54220	54313	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54223,7 +54316,7 @@
54223	54316	state.addr = 839519665163075584LLU; // skip______
54224	54317	break;
54225	54318	}
54226		- case 18446744073709549308LLU: // 99999999$6'''''''''''''''
	54319	+ case 18446744073709549306LLU: // 99999999$4'''''''''''''''
54227	54320	{
54228	54321
54229	54322	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -54245,7 +54338,7 @@
54245	54338	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54246	54339	}
54247	54340	// ACCUMULATE ARGUMENTS - END
54248		- uint64_t return_to = 18446744073709549307LLU;
	54341	+ uint64_t return_to = 18446744073709549305LLU;
54249	54342	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54250	54343	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54251	54344	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54254,7 +54347,7 @@
54254	54347	state.addr = 23446349213393492LLU; // ASSERTINIT
54255	54348	break;
54256	54349	}
54257		- case 18446744073709549307LLU: // 99999999$5'''''''''''''''
	54350	+ case 18446744073709549305LLU: // 99999999$3'''''''''''''''
54258	54351	{
54259	54352	{
54260	54353	uint64_t arg = 0;

		@@ -54333,7 +54426,7 @@
54333	54426	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54334	54427	}
54335	54428	// ACCUMULATE ARGUMENTS - END
54336		- uint64_t return_to = 18446744073709549306LLU;
	54429	+ uint64_t return_to = 18446744073709549304LLU;
54337	54430	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
54338	54431	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54339	54432	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54342,7 +54435,7 @@
54342	54435	state.addr = 293363126232490310LLU; // PROCVARREF
54343	54436	break;
54344	54437	}
54345		- case 18446744073709549306LLU: // 99999999$4'''''''''''''''
	54438	+ case 18446744073709549304LLU: // 99999999$2'''''''''''''''
54346	54439	{
54347	54440	// variable u64 initialize goes out of scope
54348	54441	// emitted destructur for type u64

		@@ -54363,7 +54456,7 @@
54363	54456	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54364	54457	}
54365	54458	// ACCUMULATE ARGUMENTS - END
54366		- uint64_t return_to = 18446744073709549305LLU;
	54459	+ uint64_t return_to = 18446744073709549303LLU;
54367	54460	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
54368	54461	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54369	54462	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54372,7 +54465,7 @@
54372	54465	state.addr = 517555565476695680LLU; // assertu64_
54373	54466	break;
54374	54467	}
54375		- case 18446744073709549305LLU: // 99999999$3'''''''''''''''
	54468	+ case 18446744073709549303LLU: // 99999999$1'''''''''''''''
54376	54469	{
54377	54470	// ACCUMULATE ARGUMENTS - BEGIN
54378	54471	{

		@@ -54380,7 +54473,7 @@
54380	54473	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54381	54474	}
54382	54475	// ACCUMULATE ARGUMENTS - END
54383		- uint64_t return_to = 18446744073709549304LLU;
	54476	+ uint64_t return_to = 18446744073709549302LLU;
54384	54477	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54385	54478	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54386	54479	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54389,7 +54482,7 @@
54389	54482	state.addr = 839519665163075584LLU; // skip______
54390	54483	break;
54391	54484	}
54392		- case 18446744073709549304LLU: // 99999999$2'''''''''''''''
	54485	+ case 18446744073709549302LLU: // 99999999$0'''''''''''''''
54393	54486	{
54394	54487	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
54395	54488	fprintf(stdout, "%s", ";");

		@@ -54401,7 +54494,7 @@
54401	54494	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54402	54495	}
54403	54496	// ACCUMULATE ARGUMENTS - END
54404		- uint64_t return_to = 18446744073709549303LLU;
	54497	+ uint64_t return_to = 18446744073709549301LLU;
54405	54498	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54406	54499	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54407	54500	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54410,7 +54503,7 @@
54410	54503	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
54411	54504	break;
54412	54505	}
54413		- case 18446744073709549303LLU: // 99999999$1'''''''''''''''
	54506	+ case 18446744073709549301LLU: // 99999999$z'''''''''''''''
54414	54507	{
54415	54508	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
54416	54509	// variable type______ type______ goes out of scope

		@@ -54421,7 +54514,7 @@
54421	54514	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54422	54515	}
54423	54516	// ACCUMULATE ARGUMENTS - END
54424		- uint64_t return_to = 18446744073709549302LLU;
	54517	+ uint64_t return_to = 18446744073709549300LLU;
54425	54518	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54426	54519	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54427	54520	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54430,7 +54523,7 @@
54430	54523	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
54431	54524	break;
54432	54525	}
54433		- case 18446744073709549302LLU: // 99999999$0'''''''''''''''
	54526	+ case 18446744073709549300LLU: // 99999999$y'''''''''''''''
54434	54527	{
54435	54528	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
54436	54529	// variable u64 mutable___ goes out of scope

		@@ -54442,10 +54535,10 @@
54442	54535	// variable u64 id________ goes out of scope
54443	54536	// emitted destructur for type u64
54444	54537	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
54445		- state.addr = 18446744073709549320LLU; // 99999999aH'''''''''''''''
	54538	+ state.addr = 18446744073709549318LLU; // 99999999aF'''''''''''''''
54446	54539	break;
54447	54540	}
54448		- case 18446744073709549321LLU: // 99999999aI'''''''''''''''
	54541	+ case 18446744073709549319LLU: // 99999999aG'''''''''''''''
54449	54542	{
54450	54543
54451	54544	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 732534228842971136;

		@@ -54456,11 +54549,11 @@
54456	54549	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
54457	54550	}
54458	54551	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
54459		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549301LLU : 18446744073709549300LLU;
	54552	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549299LLU : 18446744073709549298LLU;
54460	54553	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
54461	54554	break;
54462	54555	}
54463		- case 18446744073709549301LLU: // 99999999$z'''''''''''''''
	54556	+ case 18446744073709549299LLU: // 99999999$x'''''''''''''''
54464	54557	{
54465	54558	{
54466	54559	uint64_t arg = 0;

		@@ -54487,7 +54580,7 @@
54487	54580	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54488	54581	}
54489	54582	// ACCUMULATE ARGUMENTS - END
54490		- uint64_t return_to = 18446744073709549298LLU;
	54583	+ uint64_t return_to = 18446744073709549296LLU;
54491	54584	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54492	54585	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54493	54586	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54496,7 +54589,7 @@
54496	54589	state.addr = 861504796319285248LLU; // typeu64___
54497	54590	break;
54498	54591	}
54499		- case 18446744073709549298LLU: // 99999999$w'''''''''''''''
	54592	+ case 18446744073709549296LLU: // 99999999$u'''''''''''''''
54500	54593	{
54501	54594	{
54502	54595	uint64_t arg = 0;

		@@ -54521,7 +54614,7 @@
54521	54614	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54522	54615	}
54523	54616	// ACCUMULATE ARGUMENTS - END
54524		- uint64_t return_to = 18446744073709549296LLU;
	54617	+ uint64_t return_to = 18446744073709549294LLU;
54525	54618	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54526	54619	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54527	54620	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54530,7 +54623,7 @@
54530	54623	state.addr = 861504796319285248LLU; // typeu64___
54531	54624	break;
54532	54625	}
54533		- case 18446744073709549296LLU: // 99999999$u'''''''''''''''
	54626	+ case 18446744073709549294LLU: // 99999999$s'''''''''''''''
54534	54627	{
54535	54628	{
54536	54629	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -54550,7 +54643,7 @@
54550	54643	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54551	54644	}
54552	54645	// ACCUMULATE ARGUMENTS - END
54553		- uint64_t return_to = 18446744073709549297LLU;
	54646	+ uint64_t return_to = 18446744073709549295LLU;
54554	54647	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54555	54648	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54556	54649	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54559,7 +54652,7 @@
54559	54652	state.addr = 819859607768530944LLU; // resdest___
54560	54653	break;
54561	54654	}
54562		- case 18446744073709549297LLU: // 99999999$v'''''''''''''''
	54655	+ case 18446744073709549295LLU: // 99999999$t'''''''''''''''
54563	54656	{
54564	54657	// ACCUMULATE ARGUMENTS - BEGIN
54565	54658	{

		@@ -54579,7 +54672,7 @@
54579	54672	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54580	54673	}
54581	54674	// ACCUMULATE ARGUMENTS - END
54582		- uint64_t return_to = 18446744073709549295LLU;
	54675	+ uint64_t return_to = 18446744073709549293LLU;
54583	54676	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54584	54677	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54585	54678	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54588,7 +54681,7 @@
54588	54681	state.addr = 819857494882385920LLU; // res_u64___
54589	54682	break;
54590	54683	}
54591		- case 18446744073709549295LLU: // 99999999$t'''''''''''''''
	54684	+ case 18446744073709549293LLU: // 99999999$r'''''''''''''''
54592	54685	{
54593	54686	// ACCUMULATE ARGUMENTS - BEGIN
54594	54687	{

		@@ -54596,7 +54689,7 @@
54596	54689	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54597	54690	}
54598	54691	// ACCUMULATE ARGUMENTS - END
54599		- uint64_t return_to = 18446744073709549294LLU;
	54692	+ uint64_t return_to = 18446744073709549292LLU;
54600	54693	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54601	54694	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54602	54695	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54605,7 +54698,7 @@
54605	54698	state.addr = 839519665163075584LLU; // skip______
54606	54699	break;
54607	54700	}
54608		- case 18446744073709549294LLU: // 99999999$s'''''''''''''''
	54701	+ case 18446744073709549292LLU: // 99999999$q'''''''''''''''
54609	54702	{
54610	54703	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
54611	54704	fprintf(stdout, "%s", "\n ");

		@@ -54631,7 +54724,7 @@
54631	54724	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54632	54725	}
54633	54726	// ACCUMULATE ARGUMENTS - END
54634		- uint64_t return_to = 18446744073709549293LLU;
	54727	+ uint64_t return_to = 18446744073709549291LLU;
54635	54728	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
54636	54729	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54637	54730	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54640,7 +54733,7 @@
54640	54733	state.addr = 587881357514113024LLU; // emitpar___
54641	54734	break;
54642	54735	}
54643		- case 18446744073709549293LLU: // 99999999$r'''''''''''''''
	54736	+ case 18446744073709549291LLU: // 99999999$p'''''''''''''''
54644	54737	{
54645	54738	fprintf(stdout, "%s", " = ");
54646	54739	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -54649,7 +54742,7 @@
54649	54742	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54650	54743	}
54651	54744	// ACCUMULATE ARGUMENTS - END
54652		- uint64_t return_to = 18446744073709549292LLU;
	54745	+ uint64_t return_to = 18446744073709549290LLU;
54653	54746	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54654	54747	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54655	54748	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54658,7 +54751,7 @@
54658	54751	state.addr = 839519665163075584LLU; // skip______
54659	54752	break;
54660	54753	}
54661		- case 18446744073709549292LLU: // 99999999$q'''''''''''''''
	54754	+ case 18446744073709549290LLU: // 99999999$o'''''''''''''''
54662	54755	{
54663	54756
54664	54757	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -54680,7 +54773,7 @@
54680	54773	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54681	54774	}
54682	54775	// ACCUMULATE ARGUMENTS - END
54683		- uint64_t return_to = 18446744073709549291LLU;
	54776	+ uint64_t return_to = 18446744073709549289LLU;
54684	54777	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54685	54778	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54686	54779	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54689,7 +54782,7 @@
54689	54782	state.addr = 23446349213393492LLU; // ASSERTINIT
54690	54783	break;
54691	54784	}
54692		- case 18446744073709549291LLU: // 99999999$p'''''''''''''''
	54785	+ case 18446744073709549289LLU: // 99999999$n'''''''''''''''
54693	54786	{
54694	54787	{
54695	54788	uint64_t arg = 0;

		@@ -54768,7 +54861,7 @@
54768	54861	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54769	54862	}
54770	54863	// ACCUMULATE ARGUMENTS - END
54771		- uint64_t return_to = 18446744073709549290LLU;
	54864	+ uint64_t return_to = 18446744073709549288LLU;
54772	54865	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
54773	54866	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54774	54867	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54777,7 +54870,7 @@
54777	54870	state.addr = 293363126232490310LLU; // PROCVARREF
54778	54871	break;
54779	54872	}
54780		- case 18446744073709549290LLU: // 99999999$o'''''''''''''''
	54873	+ case 18446744073709549288LLU: // 99999999$m'''''''''''''''
54781	54874	{
54782	54875	// variable u64 initialize goes out of scope
54783	54876	// emitted destructur for type u64

		@@ -54798,7 +54891,7 @@
54798	54891	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54799	54892	}
54800	54893	// ACCUMULATE ARGUMENTS - END
54801		- uint64_t return_to = 18446744073709549289LLU;
	54894	+ uint64_t return_to = 18446744073709549287LLU;
54802	54895	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
54803	54896	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54804	54897	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54807,7 +54900,7 @@
54807	54900	state.addr = 517555565476695680LLU; // assertu64_
54808	54901	break;
54809	54902	}
54810		- case 18446744073709549289LLU: // 99999999$n'''''''''''''''
	54903	+ case 18446744073709549287LLU: // 99999999$l'''''''''''''''
54811	54904	{
54812	54905	// ACCUMULATE ARGUMENTS - BEGIN
54813	54906	{

		@@ -54815,7 +54908,7 @@
54815	54908	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54816	54909	}
54817	54910	// ACCUMULATE ARGUMENTS - END
54818		- uint64_t return_to = 18446744073709549288LLU;
	54911	+ uint64_t return_to = 18446744073709549286LLU;
54819	54912	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54820	54913	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54821	54914	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54824,7 +54917,7 @@
54824	54917	state.addr = 839519665163075584LLU; // skip______
54825	54918	break;
54826	54919	}
54827		- case 18446744073709549288LLU: // 99999999$m'''''''''''''''
	54920	+ case 18446744073709549286LLU: // 99999999$k'''''''''''''''
54828	54921	{
54829	54922	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
54830	54923	fprintf(stdout, "%s", " % ");

		@@ -54834,7 +54927,7 @@
54834	54927	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54835	54928	}
54836	54929	// ACCUMULATE ARGUMENTS - END
54837		- uint64_t return_to = 18446744073709549287LLU;
	54930	+ uint64_t return_to = 18446744073709549285LLU;
54838	54931	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
54839	54932	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54840	54933	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54843,7 +54936,7 @@
54843	54936	state.addr = 839519665163075584LLU; // skip______
54844	54937	break;
54845	54938	}
54846		- case 18446744073709549287LLU: // 99999999$l'''''''''''''''
	54939	+ case 18446744073709549285LLU: // 99999999$j'''''''''''''''
54847	54940	{
54848	54941
54849	54942	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -54865,7 +54958,7 @@
54865	54958	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54866	54959	}
54867	54960	// ACCUMULATE ARGUMENTS - END
54868		- uint64_t return_to = 18446744073709549286LLU;
	54961	+ uint64_t return_to = 18446744073709549284LLU;
54869	54962	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
54870	54963	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54871	54964	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54874,7 +54967,7 @@
54874	54967	state.addr = 23446349213393492LLU; // ASSERTINIT
54875	54968	break;
54876	54969	}
54877		- case 18446744073709549286LLU: // 99999999$k'''''''''''''''
	54970	+ case 18446744073709549284LLU: // 99999999$i'''''''''''''''
54878	54971	{
54879	54972	{
54880	54973	uint64_t arg = 0;

		@@ -54953,7 +55046,7 @@
54953	55046	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54954	55047	}
54955	55048	// ACCUMULATE ARGUMENTS - END
54956		- uint64_t return_to = 18446744073709549285LLU;
	55049	+ uint64_t return_to = 18446744073709549283LLU;
54957	55050	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
54958	55051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54959	55052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54962,7 +55055,7 @@
54962	55055	state.addr = 293363126232490310LLU; // PROCVARREF
54963	55056	break;
54964	55057	}
54965		- case 18446744073709549285LLU: // 99999999$j'''''''''''''''
	55058	+ case 18446744073709549283LLU: // 99999999$h'''''''''''''''
54966	55059	{
54967	55060	// variable u64 initialize goes out of scope
54968	55061	// emitted destructur for type u64

		@@ -54983,7 +55076,7 @@
54983	55076	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
54984	55077	}
54985	55078	// ACCUMULATE ARGUMENTS - END
54986		- uint64_t return_to = 18446744073709549284LLU;
	55079	+ uint64_t return_to = 18446744073709549282LLU;
54987	55080	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
54988	55081	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
54989	55082	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -54992,7 +55085,7 @@
54992	55085	state.addr = 517555565476695680LLU; // assertu64_
54993	55086	break;
54994	55087	}
54995		- case 18446744073709549284LLU: // 99999999$i'''''''''''''''
	55088	+ case 18446744073709549282LLU: // 99999999$g'''''''''''''''
54996	55089	{
54997	55090	// ACCUMULATE ARGUMENTS - BEGIN
54998	55091	{

		@@ -55000,7 +55093,7 @@
55000	55093	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55001	55094	}
55002	55095	// ACCUMULATE ARGUMENTS - END
55003		- uint64_t return_to = 18446744073709549283LLU;
	55096	+ uint64_t return_to = 18446744073709549281LLU;
55004	55097	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55005	55098	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55006	55099	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55009,7 +55102,7 @@
55009	55102	state.addr = 839519665163075584LLU; // skip______
55010	55103	break;
55011	55104	}
55012		- case 18446744073709549283LLU: // 99999999$h'''''''''''''''
	55105	+ case 18446744073709549281LLU: // 99999999$f'''''''''''''''
55013	55106	{
55014	55107	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
55015	55108	fprintf(stdout, "%s", ";");

		@@ -55021,7 +55114,7 @@
55021	55114	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55022	55115	}
55023	55116	// ACCUMULATE ARGUMENTS - END
55024		- uint64_t return_to = 18446744073709549282LLU;
	55117	+ uint64_t return_to = 18446744073709549280LLU;
55025	55118	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55026	55119	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55027	55120	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55030,7 +55123,7 @@
55030	55123	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
55031	55124	break;
55032	55125	}
55033		- case 18446744073709549282LLU: // 99999999$g'''''''''''''''
	55126	+ case 18446744073709549280LLU: // 99999999$e'''''''''''''''
55034	55127	{
55035	55128	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
55036	55129	// variable type______ type______ goes out of scope

		@@ -55041,7 +55134,7 @@
55041	55134	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55042	55135	}
55043	55136	// ACCUMULATE ARGUMENTS - END
55044		- uint64_t return_to = 18446744073709549281LLU;
	55137	+ uint64_t return_to = 18446744073709549279LLU;
55045	55138	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55046	55139	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55047	55140	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55050,7 +55143,7 @@
55050	55143	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
55051	55144	break;
55052	55145	}
55053		- case 18446744073709549281LLU: // 99999999$f'''''''''''''''
	55146	+ case 18446744073709549279LLU: // 99999999$d'''''''''''''''
55054	55147	{
55055	55148	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
55056	55149	// variable u64 mutable___ goes out of scope

		@@ -55062,10 +55155,10 @@
55062	55155	// variable u64 id________ goes out of scope
55063	55156	// emitted destructur for type u64
55064	55157	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
55065		- state.addr = 18446744073709549299LLU; // 99999999$x'''''''''''''''
	55158	+ state.addr = 18446744073709549297LLU; // 99999999$v'''''''''''''''
55066	55159	break;
55067	55160	}
55068		- case 18446744073709549300LLU: // 99999999$y'''''''''''''''
	55161	+ case 18446744073709549298LLU: // 99999999$w'''''''''''''''
55069	55162	{
55070	55163
55071	55164	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 589056757511225344;

		@@ -55076,11 +55169,11 @@
55076	55169	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
55077	55170	}
55078	55171	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
55079		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549280LLU : 18446744073709549279LLU;
	55172	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549278LLU : 18446744073709549277LLU;
55080	55173	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
55081	55174	break;
55082	55175	}
55083		- case 18446744073709549280LLU: // 99999999$e'''''''''''''''
	55176	+ case 18446744073709549278LLU: // 99999999$c'''''''''''''''
55084	55177	{
55085	55178	{
55086	55179	uint64_t arg = 0;

		@@ -55107,7 +55200,7 @@
55107	55200	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55108	55201	}
55109	55202	// ACCUMULATE ARGUMENTS - END
55110		- uint64_t return_to = 18446744073709549277LLU;
	55203	+ uint64_t return_to = 18446744073709549275LLU;
55111	55204	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55112	55205	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55113	55206	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55116,7 +55209,7 @@
55116	55209	state.addr = 861504796319285248LLU; // typeu64___
55117	55210	break;
55118	55211	}
55119		- case 18446744073709549277LLU: // 99999999$b'''''''''''''''
	55212	+ case 18446744073709549275LLU: // 99999999$$'''''''''''''''
55120	55213	{
55121	55214	{
55122	55215	uint64_t arg = 0;

		@@ -55141,7 +55234,7 @@
55141	55234	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55142	55235	}
55143	55236	// ACCUMULATE ARGUMENTS - END
55144		- uint64_t return_to = 18446744073709549275LLU;
	55237	+ uint64_t return_to = 18446744073709549273LLU;
55145	55238	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55146	55239	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55147	55240	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55150,7 +55243,7 @@
55150	55243	state.addr = 861504796319285248LLU; // typeu64___
55151	55244	break;
55152	55245	}
55153		- case 18446744073709549275LLU: // 99999999$$'''''''''''''''
	55246	+ case 18446744073709549273LLU: // 99999999$Y'''''''''''''''
55154	55247	{
55155	55248	{
55156	55249	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -55170,7 +55263,7 @@
55170	55263	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55171	55264	}
55172	55265	// ACCUMULATE ARGUMENTS - END
55173		- uint64_t return_to = 18446744073709549276LLU;
	55266	+ uint64_t return_to = 18446744073709549274LLU;
55174	55267	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55175	55268	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55176	55269	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55179,7 +55272,7 @@
55179	55272	state.addr = 819859607768530944LLU; // resdest___
55180	55273	break;
55181	55274	}
55182		- case 18446744073709549276LLU: // 99999999$a'''''''''''''''
	55275	+ case 18446744073709549274LLU: // 99999999$Z'''''''''''''''
55183	55276	{
55184	55277	// ACCUMULATE ARGUMENTS - BEGIN
55185	55278	{

		@@ -55199,7 +55292,7 @@
55199	55292	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55200	55293	}
55201	55294	// ACCUMULATE ARGUMENTS - END
55202		- uint64_t return_to = 18446744073709549274LLU;
	55295	+ uint64_t return_to = 18446744073709549272LLU;
55203	55296	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55204	55297	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55205	55298	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55208,7 +55301,7 @@
55208	55301	state.addr = 819857494882385920LLU; // res_u64___
55209	55302	break;
55210	55303	}
55211		- case 18446744073709549274LLU: // 99999999$Z'''''''''''''''
	55304	+ case 18446744073709549272LLU: // 99999999$X'''''''''''''''
55212	55305	{
55213	55306	// ACCUMULATE ARGUMENTS - BEGIN
55214	55307	{

		@@ -55216,7 +55309,7 @@
55216	55309	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55217	55310	}
55218	55311	// ACCUMULATE ARGUMENTS - END
55219		- uint64_t return_to = 18446744073709549273LLU;
	55312	+ uint64_t return_to = 18446744073709549271LLU;
55220	55313	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55221	55314	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55222	55315	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55225,7 +55318,7 @@
55225	55318	state.addr = 839519665163075584LLU; // skip______
55226	55319	break;
55227	55320	}
55228		- case 18446744073709549273LLU: // 99999999$Y'''''''''''''''
	55321	+ case 18446744073709549271LLU: // 99999999$W'''''''''''''''
55229	55322	{
55230	55323	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
55231	55324	fprintf(stdout, "%s", "\n ");

		@@ -55251,7 +55344,7 @@
55251	55344	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55252	55345	}
55253	55346	// ACCUMULATE ARGUMENTS - END
55254		- uint64_t return_to = 18446744073709549272LLU;
	55347	+ uint64_t return_to = 18446744073709549270LLU;
55255	55348	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
55256	55349	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55257	55350	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55260,7 +55353,7 @@
55260	55353	state.addr = 587881357514113024LLU; // emitpar___
55261	55354	break;
55262	55355	}
55263		- case 18446744073709549272LLU: // 99999999$X'''''''''''''''
	55356	+ case 18446744073709549270LLU: // 99999999$V'''''''''''''''
55264	55357	{
55265	55358	fprintf(stdout, "%s", " = ");
55266	55359	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -55269,7 +55362,7 @@
55269	55362	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55270	55363	}
55271	55364	// ACCUMULATE ARGUMENTS - END
55272		- uint64_t return_to = 18446744073709549271LLU;
	55365	+ uint64_t return_to = 18446744073709549269LLU;
55273	55366	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55274	55367	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55275	55368	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55278,7 +55371,7 @@
55278	55371	state.addr = 839519665163075584LLU; // skip______
55279	55372	break;
55280	55373	}
55281		- case 18446744073709549271LLU: // 99999999$W'''''''''''''''
	55374	+ case 18446744073709549269LLU: // 99999999$U'''''''''''''''
55282	55375	{
55283	55376
55284	55377	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -55300,7 +55393,7 @@
55300	55393	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55301	55394	}
55302	55395	// ACCUMULATE ARGUMENTS - END
55303		- uint64_t return_to = 18446744073709549270LLU;
	55396	+ uint64_t return_to = 18446744073709549268LLU;
55304	55397	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55305	55398	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55306	55399	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55309,7 +55402,7 @@
55309	55402	state.addr = 23446349213393492LLU; // ASSERTINIT
55310	55403	break;
55311	55404	}
55312		- case 18446744073709549270LLU: // 99999999$V'''''''''''''''
	55405	+ case 18446744073709549268LLU: // 99999999$T'''''''''''''''
55313	55406	{
55314	55407	{
55315	55408	uint64_t arg = 0;

		@@ -55388,7 +55481,7 @@
55388	55481	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55389	55482	}
55390	55483	// ACCUMULATE ARGUMENTS - END
55391		- uint64_t return_to = 18446744073709549269LLU;
	55484	+ uint64_t return_to = 18446744073709549267LLU;
55392	55485	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
55393	55486	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55394	55487	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55397,7 +55490,7 @@
55397	55490	state.addr = 293363126232490310LLU; // PROCVARREF
55398	55491	break;
55399	55492	}
55400		- case 18446744073709549269LLU: // 99999999$U'''''''''''''''
	55493	+ case 18446744073709549267LLU: // 99999999$S'''''''''''''''
55401	55494	{
55402	55495	// variable u64 initialize goes out of scope
55403	55496	// emitted destructur for type u64

		@@ -55418,7 +55511,7 @@
55418	55511	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55419	55512	}
55420	55513	// ACCUMULATE ARGUMENTS - END
55421		- uint64_t return_to = 18446744073709549268LLU;
	55514	+ uint64_t return_to = 18446744073709549266LLU;
55422	55515	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55423	55516	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55424	55517	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55427,7 +55520,7 @@
55427	55520	state.addr = 517555565476695680LLU; // assertu64_
55428	55521	break;
55429	55522	}
55430		- case 18446744073709549268LLU: // 99999999$T'''''''''''''''
	55523	+ case 18446744073709549266LLU: // 99999999$R'''''''''''''''
55431	55524	{
55432	55525	// ACCUMULATE ARGUMENTS - BEGIN
55433	55526	{

		@@ -55435,7 +55528,7 @@
55435	55528	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55436	55529	}
55437	55530	// ACCUMULATE ARGUMENTS - END
55438		- uint64_t return_to = 18446744073709549267LLU;
	55531	+ uint64_t return_to = 18446744073709549265LLU;
55439	55532	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55440	55533	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55441	55534	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55444,7 +55537,7 @@
55444	55537	state.addr = 839519665163075584LLU; // skip______
55445	55538	break;
55446	55539	}
55447		- case 18446744073709549267LLU: // 99999999$S'''''''''''''''
	55540	+ case 18446744073709549265LLU: // 99999999$Q'''''''''''''''
55448	55541	{
55449	55542	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
55450	55543	fprintf(stdout, "%s", " == ");

		@@ -55454,7 +55547,7 @@
55454	55547	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55455	55548	}
55456	55549	// ACCUMULATE ARGUMENTS - END
55457		- uint64_t return_to = 18446744073709549266LLU;
	55550	+ uint64_t return_to = 18446744073709549264LLU;
55458	55551	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55459	55552	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55460	55553	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55463,7 +55556,7 @@
55463	55556	state.addr = 839519665163075584LLU; // skip______
55464	55557	break;
55465	55558	}
55466		- case 18446744073709549266LLU: // 99999999$R'''''''''''''''
	55559	+ case 18446744073709549264LLU: // 99999999$P'''''''''''''''
55467	55560	{
55468	55561
55469	55562	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -55485,7 +55578,7 @@
55485	55578	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55486	55579	}
55487	55580	// ACCUMULATE ARGUMENTS - END
55488		- uint64_t return_to = 18446744073709549265LLU;
	55581	+ uint64_t return_to = 18446744073709549263LLU;
55489	55582	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55490	55583	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55491	55584	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55494,7 +55587,7 @@
55494	55587	state.addr = 23446349213393492LLU; // ASSERTINIT
55495	55588	break;
55496	55589	}
55497		- case 18446744073709549265LLU: // 99999999$Q'''''''''''''''
	55590	+ case 18446744073709549263LLU: // 99999999$O'''''''''''''''
55498	55591	{
55499	55592	{
55500	55593	uint64_t arg = 0;

		@@ -55573,7 +55666,7 @@
55573	55666	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55574	55667	}
55575	55668	// ACCUMULATE ARGUMENTS - END
55576		- uint64_t return_to = 18446744073709549264LLU;
	55669	+ uint64_t return_to = 18446744073709549262LLU;
55577	55670	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
55578	55671	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55579	55672	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55582,7 +55675,7 @@
55582	55675	state.addr = 293363126232490310LLU; // PROCVARREF
55583	55676	break;
55584	55677	}
55585		- case 18446744073709549264LLU: // 99999999$P'''''''''''''''
	55678	+ case 18446744073709549262LLU: // 99999999$N'''''''''''''''
55586	55679	{
55587	55680	// variable u64 initialize goes out of scope
55588	55681	// emitted destructur for type u64

		@@ -55603,7 +55696,7 @@
55603	55696	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55604	55697	}
55605	55698	// ACCUMULATE ARGUMENTS - END
55606		- uint64_t return_to = 18446744073709549263LLU;
	55699	+ uint64_t return_to = 18446744073709549261LLU;
55607	55700	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
55608	55701	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55609	55702	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55612,7 +55705,7 @@
55612	55705	state.addr = 517555565476695680LLU; // assertu64_
55613	55706	break;
55614	55707	}
55615		- case 18446744073709549263LLU: // 99999999$O'''''''''''''''
	55708	+ case 18446744073709549261LLU: // 99999999$M'''''''''''''''
55616	55709	{
55617	55710	// ACCUMULATE ARGUMENTS - BEGIN
55618	55711	{

		@@ -55620,7 +55713,7 @@
55620	55713	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55621	55714	}
55622	55715	// ACCUMULATE ARGUMENTS - END
55623		- uint64_t return_to = 18446744073709549262LLU;
	55716	+ uint64_t return_to = 18446744073709549260LLU;
55624	55717	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55625	55718	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55626	55719	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55629,7 +55722,7 @@
55629	55722	state.addr = 839519665163075584LLU; // skip______
55630	55723	break;
55631	55724	}
55632		- case 18446744073709549262LLU: // 99999999$N'''''''''''''''
	55725	+ case 18446744073709549260LLU: // 99999999$L'''''''''''''''
55633	55726	{
55634	55727	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
55635	55728	fprintf(stdout, "%s", ";");

		@@ -55641,7 +55734,7 @@
55641	55734	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55642	55735	}
55643	55736	// ACCUMULATE ARGUMENTS - END
55644		- uint64_t return_to = 18446744073709549261LLU;
	55737	+ uint64_t return_to = 18446744073709549259LLU;
55645	55738	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55646	55739	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55647	55740	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55650,7 +55743,7 @@
55650	55743	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
55651	55744	break;
55652	55745	}
55653		- case 18446744073709549261LLU: // 99999999$M'''''''''''''''
	55746	+ case 18446744073709549259LLU: // 99999999$K'''''''''''''''
55654	55747	{
55655	55748	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
55656	55749	// variable type______ type______ goes out of scope

		@@ -55661,7 +55754,7 @@
55661	55754	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55662	55755	}
55663	55756	// ACCUMULATE ARGUMENTS - END
55664		- uint64_t return_to = 18446744073709549260LLU;
	55757	+ uint64_t return_to = 18446744073709549258LLU;
55665	55758	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55666	55759	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55667	55760	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55670,7 +55763,7 @@
55670	55763	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
55671	55764	break;
55672	55765	}
55673		- case 18446744073709549260LLU: // 99999999$L'''''''''''''''
	55766	+ case 18446744073709549258LLU: // 99999999$J'''''''''''''''
55674	55767	{
55675	55768	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
55676	55769	// variable u64 mutable___ goes out of scope

		@@ -55682,10 +55775,10 @@
55682	55775	// variable u64 id________ goes out of scope
55683	55776	// emitted destructur for type u64
55684	55777	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
55685		- state.addr = 18446744073709549278LLU; // 99999999$c'''''''''''''''
	55778	+ state.addr = 18446744073709549276LLU; // 99999999$a'''''''''''''''
55686	55779	break;
55687	55780	}
55688		- case 18446744073709549279LLU: // 99999999$d'''''''''''''''
	55781	+ case 18446744073709549277LLU: // 99999999$b'''''''''''''''
55689	55782	{
55690	55783
55691	55784	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 747791052189990912;

		@@ -55696,11 +55789,11 @@
55696	55789	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
55697	55790	}
55698	55791	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
55699		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549259LLU : 18446744073709549258LLU;
	55792	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549257LLU : 18446744073709549256LLU;
55700	55793	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
55701	55794	break;
55702	55795	}
55703		- case 18446744073709549259LLU: // 99999999$K'''''''''''''''
	55796	+ case 18446744073709549257LLU: // 99999999$I'''''''''''''''
55704	55797	{
55705	55798	{
55706	55799	uint64_t arg = 0;

		@@ -55727,7 +55820,7 @@
55727	55820	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55728	55821	}
55729	55822	// ACCUMULATE ARGUMENTS - END
55730		- uint64_t return_to = 18446744073709549256LLU;
	55823	+ uint64_t return_to = 18446744073709549254LLU;
55731	55824	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55732	55825	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55733	55826	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55736,7 +55829,7 @@
55736	55829	state.addr = 861504796319285248LLU; // typeu64___
55737	55830	break;
55738	55831	}
55739		- case 18446744073709549256LLU: // 99999999$H'''''''''''''''
	55832	+ case 18446744073709549254LLU: // 99999999$F'''''''''''''''
55740	55833	{
55741	55834	{
55742	55835	uint64_t arg = 0;

		@@ -55761,7 +55854,7 @@
55761	55854	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55762	55855	}
55763	55856	// ACCUMULATE ARGUMENTS - END
55764		- uint64_t return_to = 18446744073709549254LLU;
	55857	+ uint64_t return_to = 18446744073709549252LLU;
55765	55858	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55766	55859	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55767	55860	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55770,7 +55863,7 @@
55770	55863	state.addr = 861504796319285248LLU; // typeu64___
55771	55864	break;
55772	55865	}
55773		- case 18446744073709549254LLU: // 99999999$F'''''''''''''''
	55866	+ case 18446744073709549252LLU: // 99999999$D'''''''''''''''
55774	55867	{
55775	55868	{
55776	55869	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -55790,7 +55883,7 @@
55790	55883	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55791	55884	}
55792	55885	// ACCUMULATE ARGUMENTS - END
55793		- uint64_t return_to = 18446744073709549255LLU;
	55886	+ uint64_t return_to = 18446744073709549253LLU;
55794	55887	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55795	55888	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55796	55889	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55799,7 +55892,7 @@
55799	55892	state.addr = 819859607768530944LLU; // resdest___
55800	55893	break;
55801	55894	}
55802		- case 18446744073709549255LLU: // 99999999$G'''''''''''''''
	55895	+ case 18446744073709549253LLU: // 99999999$E'''''''''''''''
55803	55896	{
55804	55897	// ACCUMULATE ARGUMENTS - BEGIN
55805	55898	{

		@@ -55819,7 +55912,7 @@
55819	55912	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55820	55913	}
55821	55914	// ACCUMULATE ARGUMENTS - END
55822		- uint64_t return_to = 18446744073709549253LLU;
	55915	+ uint64_t return_to = 18446744073709549251LLU;
55823	55916	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55824	55917	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55825	55918	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55828,7 +55921,7 @@
55828	55921	state.addr = 819857494882385920LLU; // res_u64___
55829	55922	break;
55830	55923	}
55831		- case 18446744073709549253LLU: // 99999999$E'''''''''''''''
	55924	+ case 18446744073709549251LLU: // 99999999$C'''''''''''''''
55832	55925	{
55833	55926	// ACCUMULATE ARGUMENTS - BEGIN
55834	55927	{

		@@ -55836,7 +55929,7 @@
55836	55929	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55837	55930	}
55838	55931	// ACCUMULATE ARGUMENTS - END
55839		- uint64_t return_to = 18446744073709549252LLU;
	55932	+ uint64_t return_to = 18446744073709549250LLU;
55840	55933	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55841	55934	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55842	55935	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55845,7 +55938,7 @@
55845	55938	state.addr = 839519665163075584LLU; // skip______
55846	55939	break;
55847	55940	}
55848		- case 18446744073709549252LLU: // 99999999$D'''''''''''''''
	55941	+ case 18446744073709549250LLU: // 99999999$B'''''''''''''''
55849	55942	{
55850	55943	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
55851	55944	fprintf(stdout, "%s", "\n ");

		@@ -55871,7 +55964,7 @@
55871	55964	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55872	55965	}
55873	55966	// ACCUMULATE ARGUMENTS - END
55874		- uint64_t return_to = 18446744073709549251LLU;
	55967	+ uint64_t return_to = 18446744073709549249LLU;
55875	55968	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
55876	55969	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55877	55970	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55880,7 +55973,7 @@
55880	55973	state.addr = 587881357514113024LLU; // emitpar___
55881	55974	break;
55882	55975	}
55883		- case 18446744073709549251LLU: // 99999999$C'''''''''''''''
	55976	+ case 18446744073709549249LLU: // 99999999$A'''''''''''''''
55884	55977	{
55885	55978	fprintf(stdout, "%s", " = ");
55886	55979	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -55889,7 +55982,7 @@
55889	55982	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55890	55983	}
55891	55984	// ACCUMULATE ARGUMENTS - END
55892		- uint64_t return_to = 18446744073709549250LLU;
	55985	+ uint64_t return_to = 18446744073709549248LLU;
55893	55986	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
55894	55987	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55895	55988	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55898,7 +55991,7 @@
55898	55991	state.addr = 839519665163075584LLU; // skip______
55899	55992	break;
55900	55993	}
55901		- case 18446744073709549250LLU: // 99999999$B'''''''''''''''
	55994	+ case 18446744073709549248LLU: // 99999999$_'''''''''''''''
55902	55995	{
55903	55996
55904	55997	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -55920,7 +56013,7 @@
55920	56013	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
55921	56014	}
55922	56015	// ACCUMULATE ARGUMENTS - END
55923		- uint64_t return_to = 18446744073709549249LLU;
	56016	+ uint64_t return_to = 18446744073709549247LLU;
55924	56017	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
55925	56018	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
55926	56019	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -55929,7 +56022,7 @@
55929	56022	state.addr = 23446349213393492LLU; // ASSERTINIT
55930	56023	break;
55931	56024	}
55932		- case 18446744073709549249LLU: // 99999999$A'''''''''''''''
	56025	+ case 18446744073709549247LLU: // 99999999Z9'''''''''''''''
55933	56026	{
55934	56027	{
55935	56028	uint64_t arg = 0;

		@@ -56008,7 +56101,7 @@
56008	56101	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56009	56102	}
56010	56103	// ACCUMULATE ARGUMENTS - END
56011		- uint64_t return_to = 18446744073709549248LLU;
	56104	+ uint64_t return_to = 18446744073709549246LLU;
56012	56105	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
56013	56106	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56014	56107	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56017,7 +56110,7 @@
56017	56110	state.addr = 293363126232490310LLU; // PROCVARREF
56018	56111	break;
56019	56112	}
56020		- case 18446744073709549248LLU: // 99999999$_'''''''''''''''
	56113	+ case 18446744073709549246LLU: // 99999999Z8'''''''''''''''
56021	56114	{
56022	56115	// variable u64 initialize goes out of scope
56023	56116	// emitted destructur for type u64

		@@ -56038,7 +56131,7 @@
56038	56131	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56039	56132	}
56040	56133	// ACCUMULATE ARGUMENTS - END
56041		- uint64_t return_to = 18446744073709549247LLU;
	56134	+ uint64_t return_to = 18446744073709549245LLU;
56042	56135	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
56043	56136	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56044	56137	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56047,7 +56140,7 @@
56047	56140	state.addr = 517555565476695680LLU; // assertu64_
56048	56141	break;
56049	56142	}
56050		- case 18446744073709549247LLU: // 99999999Z9'''''''''''''''
	56143	+ case 18446744073709549245LLU: // 99999999Z7'''''''''''''''
56051	56144	{
56052	56145	// ACCUMULATE ARGUMENTS - BEGIN
56053	56146	{

		@@ -56055,7 +56148,7 @@
56055	56148	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56056	56149	}
56057	56150	// ACCUMULATE ARGUMENTS - END
56058		- uint64_t return_to = 18446744073709549246LLU;
	56151	+ uint64_t return_to = 18446744073709549244LLU;
56059	56152	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56060	56153	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56061	56154	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56064,7 +56157,7 @@
56064	56157	state.addr = 839519665163075584LLU; // skip______
56065	56158	break;
56066	56159	}
56067		- case 18446744073709549246LLU: // 99999999Z8'''''''''''''''
	56160	+ case 18446744073709549244LLU: // 99999999Z6'''''''''''''''
56068	56161	{
56069	56162	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
56070	56163	fprintf(stdout, "%s", " != ");

		@@ -56074,7 +56167,7 @@
56074	56167	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56075	56168	}
56076	56169	// ACCUMULATE ARGUMENTS - END
56077		- uint64_t return_to = 18446744073709549245LLU;
	56170	+ uint64_t return_to = 18446744073709549243LLU;
56078	56171	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56079	56172	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56080	56173	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56083,7 +56176,7 @@
56083	56176	state.addr = 839519665163075584LLU; // skip______
56084	56177	break;
56085	56178	}
56086		- case 18446744073709549245LLU: // 99999999Z7'''''''''''''''
	56179	+ case 18446744073709549243LLU: // 99999999Z5'''''''''''''''
56087	56180	{
56088	56181
56089	56182	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -56105,7 +56198,7 @@
56105	56198	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56106	56199	}
56107	56200	// ACCUMULATE ARGUMENTS - END
56108		- uint64_t return_to = 18446744073709549244LLU;
	56201	+ uint64_t return_to = 18446744073709549242LLU;
56109	56202	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
56110	56203	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56111	56204	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56114,7 +56207,7 @@
56114	56207	state.addr = 23446349213393492LLU; // ASSERTINIT
56115	56208	break;
56116	56209	}
56117		- case 18446744073709549244LLU: // 99999999Z6'''''''''''''''
	56210	+ case 18446744073709549242LLU: // 99999999Z4'''''''''''''''
56118	56211	{
56119	56212	{
56120	56213	uint64_t arg = 0;

		@@ -56193,7 +56286,7 @@
56193	56286	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56194	56287	}
56195	56288	// ACCUMULATE ARGUMENTS - END
56196		- uint64_t return_to = 18446744073709549243LLU;
	56289	+ uint64_t return_to = 18446744073709549241LLU;
56197	56290	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
56198	56291	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56199	56292	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56202,7 +56295,7 @@
56202	56295	state.addr = 293363126232490310LLU; // PROCVARREF
56203	56296	break;
56204	56297	}
56205		- case 18446744073709549243LLU: // 99999999Z5'''''''''''''''
	56298	+ case 18446744073709549241LLU: // 99999999Z3'''''''''''''''
56206	56299	{
56207	56300	// variable u64 initialize goes out of scope
56208	56301	// emitted destructur for type u64

		@@ -56223,7 +56316,7 @@
56223	56316	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56224	56317	}
56225	56318	// ACCUMULATE ARGUMENTS - END
56226		- uint64_t return_to = 18446744073709549242LLU;
	56319	+ uint64_t return_to = 18446744073709549240LLU;
56227	56320	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
56228	56321	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56229	56322	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56232,7 +56325,7 @@
56232	56325	state.addr = 517555565476695680LLU; // assertu64_
56233	56326	break;
56234	56327	}
56235		- case 18446744073709549242LLU: // 99999999Z4'''''''''''''''
	56328	+ case 18446744073709549240LLU: // 99999999Z2'''''''''''''''
56236	56329	{
56237	56330	// ACCUMULATE ARGUMENTS - BEGIN
56238	56331	{

		@@ -56240,7 +56333,7 @@
56240	56333	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56241	56334	}
56242	56335	// ACCUMULATE ARGUMENTS - END
56243		- uint64_t return_to = 18446744073709549241LLU;
	56336	+ uint64_t return_to = 18446744073709549239LLU;
56244	56337	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56245	56338	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56246	56339	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56249,7 +56342,7 @@
56249	56342	state.addr = 839519665163075584LLU; // skip______
56250	56343	break;
56251	56344	}
56252		- case 18446744073709549241LLU: // 99999999Z3'''''''''''''''
	56345	+ case 18446744073709549239LLU: // 99999999Z1'''''''''''''''
56253	56346	{
56254	56347	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
56255	56348	fprintf(stdout, "%s", ";");

		@@ -56261,7 +56354,7 @@
56261	56354	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56262	56355	}
56263	56356	// ACCUMULATE ARGUMENTS - END
56264		- uint64_t return_to = 18446744073709549240LLU;
	56357	+ uint64_t return_to = 18446744073709549238LLU;
56265	56358	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56266	56359	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56267	56360	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56270,7 +56363,7 @@
56270	56363	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
56271	56364	break;
56272	56365	}
56273		- case 18446744073709549240LLU: // 99999999Z2'''''''''''''''
	56366	+ case 18446744073709549238LLU: // 99999999Z0'''''''''''''''
56274	56367	{
56275	56368	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
56276	56369	// variable type______ type______ goes out of scope

		@@ -56281,7 +56374,7 @@
56281	56374	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56282	56375	}
56283	56376	// ACCUMULATE ARGUMENTS - END
56284		- uint64_t return_to = 18446744073709549239LLU;
	56377	+ uint64_t return_to = 18446744073709549237LLU;
56285	56378	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56286	56379	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56287	56380	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56290,7 +56383,7 @@
56290	56383	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
56291	56384	break;
56292	56385	}
56293		- case 18446744073709549239LLU: // 99999999Z1'''''''''''''''
	56386	+ case 18446744073709549237LLU: // 99999999Zz'''''''''''''''
56294	56387	{
56295	56388	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
56296	56389	// variable u64 mutable___ goes out of scope

		@@ -56302,10 +56395,10 @@
56302	56395	// variable u64 id________ goes out of scope
56303	56396	// emitted destructur for type u64
56304	56397	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
56305		- state.addr = 18446744073709549257LLU; // 99999999$I'''''''''''''''
	56398	+ state.addr = 18446744073709549255LLU; // 99999999$G'''''''''''''''
56306	56399	break;
56307	56400	}
56308		- case 18446744073709549258LLU: // 99999999$J'''''''''''''''
	56401	+ case 18446744073709549256LLU: // 99999999$H'''''''''''''''
56309	56402	{
56310	56403
56311	56404	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 621690262623617024;

		@@ -56316,11 +56409,11 @@
56316	56409	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
56317	56410	}
56318	56411	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
56319		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549238LLU : 18446744073709549237LLU;
	56412	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549236LLU : 18446744073709549235LLU;
56320	56413	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
56321	56414	break;
56322	56415	}
56323		- case 18446744073709549238LLU: // 99999999Z0'''''''''''''''
	56416	+ case 18446744073709549236LLU: // 99999999Zy'''''''''''''''
56324	56417	{
56325	56418	{
56326	56419	uint64_t arg = 0;

		@@ -56347,7 +56440,7 @@
56347	56440	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56348	56441	}
56349	56442	// ACCUMULATE ARGUMENTS - END
56350		- uint64_t return_to = 18446744073709549235LLU;
	56443	+ uint64_t return_to = 18446744073709549233LLU;
56351	56444	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56352	56445	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56353	56446	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56356,7 +56449,7 @@
56356	56449	state.addr = 861504796319285248LLU; // typeu64___
56357	56450	break;
56358	56451	}
56359		- case 18446744073709549235LLU: // 99999999Zx'''''''''''''''
	56452	+ case 18446744073709549233LLU: // 99999999Zv'''''''''''''''
56360	56453	{
56361	56454	{
56362	56455	uint64_t arg = 0;

		@@ -56381,7 +56474,7 @@
56381	56474	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56382	56475	}
56383	56476	// ACCUMULATE ARGUMENTS - END
56384		- uint64_t return_to = 18446744073709549233LLU;
	56477	+ uint64_t return_to = 18446744073709549231LLU;
56385	56478	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56386	56479	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56387	56480	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56390,7 +56483,7 @@
56390	56483	state.addr = 861504796319285248LLU; // typeu64___
56391	56484	break;
56392	56485	}
56393		- case 18446744073709549233LLU: // 99999999Zv'''''''''''''''
	56486	+ case 18446744073709549231LLU: // 99999999Zt'''''''''''''''
56394	56487	{
56395	56488	{
56396	56489	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -56410,7 +56503,7 @@
56410	56503	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56411	56504	}
56412	56505	// ACCUMULATE ARGUMENTS - END
56413		- uint64_t return_to = 18446744073709549234LLU;
	56506	+ uint64_t return_to = 18446744073709549232LLU;
56414	56507	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
56415	56508	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56416	56509	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56419,7 +56512,7 @@
56419	56512	state.addr = 819859607768530944LLU; // resdest___
56420	56513	break;
56421	56514	}
56422		- case 18446744073709549234LLU: // 99999999Zw'''''''''''''''
	56515	+ case 18446744073709549232LLU: // 99999999Zu'''''''''''''''
56423	56516	{
56424	56517	// ACCUMULATE ARGUMENTS - BEGIN
56425	56518	{

		@@ -56439,7 +56532,7 @@
56439	56532	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56440	56533	}
56441	56534	// ACCUMULATE ARGUMENTS - END
56442		- uint64_t return_to = 18446744073709549232LLU;
	56535	+ uint64_t return_to = 18446744073709549230LLU;
56443	56536	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
56444	56537	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56445	56538	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56448,7 +56541,7 @@
56448	56541	state.addr = 819857494882385920LLU; // res_u64___
56449	56542	break;
56450	56543	}
56451		- case 18446744073709549232LLU: // 99999999Zu'''''''''''''''
	56544	+ case 18446744073709549230LLU: // 99999999Zs'''''''''''''''
56452	56545	{
56453	56546	// ACCUMULATE ARGUMENTS - BEGIN
56454	56547	{

		@@ -56456,7 +56549,7 @@
56456	56549	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56457	56550	}
56458	56551	// ACCUMULATE ARGUMENTS - END
56459		- uint64_t return_to = 18446744073709549231LLU;
	56552	+ uint64_t return_to = 18446744073709549229LLU;
56460	56553	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56461	56554	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56462	56555	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56465,7 +56558,7 @@
56465	56558	state.addr = 839519665163075584LLU; // skip______
56466	56559	break;
56467	56560	}
56468		- case 18446744073709549231LLU: // 99999999Zt'''''''''''''''
	56561	+ case 18446744073709549229LLU: // 99999999Zr'''''''''''''''
56469	56562	{
56470	56563	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
56471	56564	fprintf(stdout, "%s", "\n ");

		@@ -56491,7 +56584,7 @@
56491	56584	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56492	56585	}
56493	56586	// ACCUMULATE ARGUMENTS - END
56494		- uint64_t return_to = 18446744073709549230LLU;
	56587	+ uint64_t return_to = 18446744073709549228LLU;
56495	56588	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
56496	56589	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56497	56590	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56500,7 +56593,7 @@
56500	56593	state.addr = 587881357514113024LLU; // emitpar___
56501	56594	break;
56502	56595	}
56503		- case 18446744073709549230LLU: // 99999999Zs'''''''''''''''
	56596	+ case 18446744073709549228LLU: // 99999999Zq'''''''''''''''
56504	56597	{
56505	56598	fprintf(stdout, "%s", " = ");
56506	56599	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -56509,7 +56602,7 @@
56509	56602	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56510	56603	}
56511	56604	// ACCUMULATE ARGUMENTS - END
56512		- uint64_t return_to = 18446744073709549229LLU;
	56605	+ uint64_t return_to = 18446744073709549227LLU;
56513	56606	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56514	56607	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56515	56608	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56518,7 +56611,7 @@
56518	56611	state.addr = 839519665163075584LLU; // skip______
56519	56612	break;
56520	56613	}
56521		- case 18446744073709549229LLU: // 99999999Zr'''''''''''''''
	56614	+ case 18446744073709549227LLU: // 99999999Zp'''''''''''''''
56522	56615	{
56523	56616
56524	56617	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -56540,7 +56633,7 @@
56540	56633	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56541	56634	}
56542	56635	// ACCUMULATE ARGUMENTS - END
56543		- uint64_t return_to = 18446744073709549228LLU;
	56636	+ uint64_t return_to = 18446744073709549226LLU;
56544	56637	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
56545	56638	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56546	56639	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56549,7 +56642,7 @@
56549	56642	state.addr = 23446349213393492LLU; // ASSERTINIT
56550	56643	break;
56551	56644	}
56552		- case 18446744073709549228LLU: // 99999999Zq'''''''''''''''
	56645	+ case 18446744073709549226LLU: // 99999999Zo'''''''''''''''
56553	56646	{
56554	56647	{
56555	56648	uint64_t arg = 0;

		@@ -56628,7 +56721,7 @@
56628	56721	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56629	56722	}
56630	56723	// ACCUMULATE ARGUMENTS - END
56631		- uint64_t return_to = 18446744073709549227LLU;
	56724	+ uint64_t return_to = 18446744073709549225LLU;
56632	56725	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
56633	56726	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56634	56727	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56637,7 +56730,7 @@
56637	56730	state.addr = 293363126232490310LLU; // PROCVARREF
56638	56731	break;
56639	56732	}
56640		- case 18446744073709549227LLU: // 99999999Zp'''''''''''''''
	56733	+ case 18446744073709549225LLU: // 99999999Zn'''''''''''''''
56641	56734	{
56642	56735	// variable u64 initialize goes out of scope
56643	56736	// emitted destructur for type u64

		@@ -56658,7 +56751,7 @@
56658	56751	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56659	56752	}
56660	56753	// ACCUMULATE ARGUMENTS - END
56661		- uint64_t return_to = 18446744073709549226LLU;
	56754	+ uint64_t return_to = 18446744073709549224LLU;
56662	56755	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
56663	56756	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56664	56757	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56667,7 +56760,7 @@
56667	56760	state.addr = 517555565476695680LLU; // assertu64_
56668	56761	break;
56669	56762	}
56670		- case 18446744073709549226LLU: // 99999999Zo'''''''''''''''
	56763	+ case 18446744073709549224LLU: // 99999999Zm'''''''''''''''
56671	56764	{
56672	56765	// ACCUMULATE ARGUMENTS - BEGIN
56673	56766	{

		@@ -56675,7 +56768,7 @@
56675	56768	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56676	56769	}
56677	56770	// ACCUMULATE ARGUMENTS - END
56678		- uint64_t return_to = 18446744073709549225LLU;
	56771	+ uint64_t return_to = 18446744073709549223LLU;
56679	56772	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56680	56773	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56681	56774	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56684,7 +56777,7 @@
56684	56777	state.addr = 839519665163075584LLU; // skip______
56685	56778	break;
56686	56779	}
56687		- case 18446744073709549225LLU: // 99999999Zn'''''''''''''''
	56780	+ case 18446744073709549223LLU: // 99999999Zl'''''''''''''''
56688	56781	{
56689	56782	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
56690	56783	fprintf(stdout, "%s", " >= ");

		@@ -56694,7 +56787,7 @@
56694	56787	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56695	56788	}
56696	56789	// ACCUMULATE ARGUMENTS - END
56697		- uint64_t return_to = 18446744073709549224LLU;
	56790	+ uint64_t return_to = 18446744073709549222LLU;
56698	56791	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56699	56792	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56700	56793	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56703,7 +56796,7 @@
56703	56796	state.addr = 839519665163075584LLU; // skip______
56704	56797	break;
56705	56798	}
56706		- case 18446744073709549224LLU: // 99999999Zm'''''''''''''''
	56799	+ case 18446744073709549222LLU: // 99999999Zk'''''''''''''''
56707	56800	{
56708	56801
56709	56802	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -56725,7 +56818,7 @@
56725	56818	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56726	56819	}
56727	56820	// ACCUMULATE ARGUMENTS - END
56728		- uint64_t return_to = 18446744073709549223LLU;
	56821	+ uint64_t return_to = 18446744073709549221LLU;
56729	56822	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
56730	56823	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56731	56824	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56734,7 +56827,7 @@
56734	56827	state.addr = 23446349213393492LLU; // ASSERTINIT
56735	56828	break;
56736	56829	}
56737		- case 18446744073709549223LLU: // 99999999Zl'''''''''''''''
	56830	+ case 18446744073709549221LLU: // 99999999Zj'''''''''''''''
56738	56831	{
56739	56832	{
56740	56833	uint64_t arg = 0;

		@@ -56813,7 +56906,7 @@
56813	56906	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56814	56907	}
56815	56908	// ACCUMULATE ARGUMENTS - END
56816		- uint64_t return_to = 18446744073709549222LLU;
	56909	+ uint64_t return_to = 18446744073709549220LLU;
56817	56910	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
56818	56911	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56819	56912	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56822,7 +56915,7 @@
56822	56915	state.addr = 293363126232490310LLU; // PROCVARREF
56823	56916	break;
56824	56917	}
56825		- case 18446744073709549222LLU: // 99999999Zk'''''''''''''''
	56918	+ case 18446744073709549220LLU: // 99999999Zi'''''''''''''''
56826	56919	{
56827	56920	// variable u64 initialize goes out of scope
56828	56921	// emitted destructur for type u64

		@@ -56843,7 +56936,7 @@
56843	56936	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56844	56937	}
56845	56938	// ACCUMULATE ARGUMENTS - END
56846		- uint64_t return_to = 18446744073709549221LLU;
	56939	+ uint64_t return_to = 18446744073709549219LLU;
56847	56940	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
56848	56941	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56849	56942	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56852,7 +56945,7 @@
56852	56945	state.addr = 517555565476695680LLU; // assertu64_
56853	56946	break;
56854	56947	}
56855		- case 18446744073709549221LLU: // 99999999Zj'''''''''''''''
	56948	+ case 18446744073709549219LLU: // 99999999Zh'''''''''''''''
56856	56949	{
56857	56950	// ACCUMULATE ARGUMENTS - BEGIN
56858	56951	{

		@@ -56860,7 +56953,7 @@
56860	56953	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56861	56954	}
56862	56955	// ACCUMULATE ARGUMENTS - END
56863		- uint64_t return_to = 18446744073709549220LLU;
	56956	+ uint64_t return_to = 18446744073709549218LLU;
56864	56957	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56865	56958	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56866	56959	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56869,7 +56962,7 @@
56869	56962	state.addr = 839519665163075584LLU; // skip______
56870	56963	break;
56871	56964	}
56872		- case 18446744073709549220LLU: // 99999999Zi'''''''''''''''
	56965	+ case 18446744073709549218LLU: // 99999999Zg'''''''''''''''
56873	56966	{
56874	56967	matchid(")", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
56875	56968	fprintf(stdout, "%s", ";");

		@@ -56881,7 +56974,7 @@
56881	56974	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56882	56975	}
56883	56976	// ACCUMULATE ARGUMENTS - END
56884		- uint64_t return_to = 18446744073709549219LLU;
	56977	+ uint64_t return_to = 18446744073709549217LLU;
56885	56978	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56886	56979	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56887	56980	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56890,7 +56983,7 @@
56890	56983	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
56891	56984	break;
56892	56985	}
56893		- case 18446744073709549219LLU: // 99999999Zh'''''''''''''''
	56986	+ case 18446744073709549217LLU: // 99999999Zf'''''''''''''''
56894	56987	{
56895	56988	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference single____ at 21
56896	56989	// variable type______ type______ goes out of scope

		@@ -56901,7 +56994,7 @@
56901	56994	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56902	56995	}
56903	56996	// ACCUMULATE ARGUMENTS - END
56904		- uint64_t return_to = 18446744073709549218LLU;
	56997	+ uint64_t return_to = 18446744073709549216LLU;
56905	56998	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56906	56999	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56907	57000	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56910,7 +57003,7 @@
56910	57003	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
56911	57004	break;
56912	57005	}
56913		- case 18446744073709549218LLU: // 99999999Zg'''''''''''''''
	57006	+ case 18446744073709549216LLU: // 99999999Ze'''''''''''''''
56914	57007	{
56915	57008	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 20
56916	57009	// variable u64 mutable___ goes out of scope

		@@ -56922,10 +57015,10 @@
56922	57015	// variable u64 id________ goes out of scope
56923	57016	// emitted destructur for type u64
56924	57017	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 17
56925		- state.addr = 18446744073709549236LLU; // 99999999Zy'''''''''''''''
	57018	+ state.addr = 18446744073709549234LLU; // 99999999Zw'''''''''''''''
56926	57019	break;
56927	57020	}
56928		- case 18446744073709549237LLU: // 99999999Zz'''''''''''''''
	57021	+ case 18446744073709549235LLU: // 99999999Zx'''''''''''''''
56929	57022	{
56930	57023
56931	57024	*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 625916785320787968;

		@@ -56936,11 +57029,11 @@
56936	57029	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
56937	57030	}
56938	57031	LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /builtin___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU));
56939		- state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549217LLU : 18446744073709549216LLU;
	57032	+ state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549215LLU : 18446744073709549214LLU;
56940	57033	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
56941	57034	break;
56942	57035	}
56943		- case 18446744073709549217LLU: // 99999999Zf'''''''''''''''
	57036	+ case 18446744073709549215LLU: // 99999999Zd'''''''''''''''
56944	57037	{
56945	57038	{
56946	57039	uint64_t arg = 0;

		@@ -56967,7 +57060,7 @@
56967	57060	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
56968	57061	}
56969	57062	// ACCUMULATE ARGUMENTS - END
56970		- uint64_t return_to = 18446744073709549214LLU;
	57063	+ uint64_t return_to = 18446744073709549212LLU;
56971	57064	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
56972	57065	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
56973	57066	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -56976,7 +57069,7 @@
56976	57069	state.addr = 861504796319285248LLU; // typeu64___
56977	57070	break;
56978	57071	}
56979		- case 18446744073709549214LLU: // 99999999Zc'''''''''''''''
	57072	+ case 18446744073709549212LLU: // 99999999Za'''''''''''''''
56980	57073	{
56981	57074	{
56982	57075	uint64_t arg = 0;

		@@ -57001,7 +57094,7 @@
57001	57094	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57002	57095	}
57003	57096	// ACCUMULATE ARGUMENTS - END
57004		- uint64_t return_to = 18446744073709549212LLU;
	57097	+ uint64_t return_to = 18446744073709549210LLU;
57005	57098	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
57006	57099	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57007	57100	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57010,7 +57103,7 @@
57010	57103	state.addr = 861504796319285248LLU; // typeu64___
57011	57104	break;
57012	57105	}
57013		- case 18446744073709549212LLU: // 99999999Za'''''''''''''''
	57106	+ case 18446744073709549210LLU: // 99999999ZZ'''''''''''''''
57014	57107	{
57015	57108	{
57016	57109	uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 23*/;

		@@ -57030,7 +57123,7 @@
57030	57123	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57031	57124	}
57032	57125	// ACCUMULATE ARGUMENTS - END
57033		- uint64_t return_to = 18446744073709549213LLU;
	57126	+ uint64_t return_to = 18446744073709549211LLU;
57034	57127	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
57035	57128	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57036	57129	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57039,7 +57132,7 @@
57039	57132	state.addr = 819859607768530944LLU; // resdest___
57040	57133	break;
57041	57134	}
57042		- case 18446744073709549213LLU: // 99999999Zb'''''''''''''''
	57135	+ case 18446744073709549211LLU: // 99999999Z$'''''''''''''''
57043	57136	{
57044	57137	// ACCUMULATE ARGUMENTS - BEGIN
57045	57138	{

		@@ -57059,7 +57152,7 @@
57059	57152	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57060	57153	}
57061	57154	// ACCUMULATE ARGUMENTS - END
57062		- uint64_t return_to = 18446744073709549211LLU;
	57155	+ uint64_t return_to = 18446744073709549209LLU;
57063	57156	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
57064	57157	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57065	57158	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57068,7 +57161,7 @@
57068	57161	state.addr = 819857494882385920LLU; // res_u64___
57069	57162	break;
57070	57163	}
57071		- case 18446744073709549211LLU: // 99999999Z$'''''''''''''''
	57164	+ case 18446744073709549209LLU: // 99999999ZY'''''''''''''''
57072	57165	{
57073	57166	// ACCUMULATE ARGUMENTS - BEGIN
57074	57167	{

		@@ -57076,7 +57169,7 @@
57076	57169	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57077	57170	}
57078	57171	// ACCUMULATE ARGUMENTS - END
57079		- uint64_t return_to = 18446744073709549210LLU;
	57172	+ uint64_t return_to = 18446744073709549208LLU;
57080	57173	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
57081	57174	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57082	57175	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57085,7 +57178,7 @@
57085	57178	state.addr = 839519665163075584LLU; // skip______
57086	57179	break;
57087	57180	}
57088		- case 18446744073709549210LLU: // 99999999ZZ'''''''''''''''
	57181	+ case 18446744073709549208LLU: // 99999999ZX'''''''''''''''
57089	57182	{
57090	57183	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
57091	57184	fprintf(stdout, "%s", "\n ");

		@@ -57111,7 +57204,7 @@
57111	57204	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57112	57205	}
57113	57206	// ACCUMULATE ARGUMENTS - END
57114		- uint64_t return_to = 18446744073709549209LLU;
	57207	+ uint64_t return_to = 18446744073709549207LLU;
57115	57208	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
57116	57209	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57117	57210	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57120,7 +57213,7 @@
57120	57213	state.addr = 587881357514113024LLU; // emitpar___
57121	57214	break;
57122	57215	}
57123		- case 18446744073709549209LLU: // 99999999ZY'''''''''''''''
	57216	+ case 18446744073709549207LLU: // 99999999ZW'''''''''''''''
57124	57217	{
57125	57218	fprintf(stdout, "%s", " = ");
57126	57219	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -57129,7 +57222,7 @@
57129	57222	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57130	57223	}
57131	57224	// ACCUMULATE ARGUMENTS - END
57132		- uint64_t return_to = 18446744073709549208LLU;
	57225	+ uint64_t return_to = 18446744073709549206LLU;
57133	57226	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
57134	57227	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57135	57228	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57138,7 +57231,7 @@
57138	57231	state.addr = 839519665163075584LLU; // skip______
57139	57232	break;
57140	57233	}
57141		- case 18446744073709549208LLU: // 99999999ZX'''''''''''''''
	57234	+ case 18446744073709549206LLU: // 99999999ZV'''''''''''''''
57142	57235	{
57143	57236
57144	57237	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -57160,7 +57253,7 @@
57160	57253	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57161	57254	}
57162	57255	// ACCUMULATE ARGUMENTS - END
57163		- uint64_t return_to = 18446744073709549207LLU;
	57256	+ uint64_t return_to = 18446744073709549205LLU;
57164	57257	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
57165	57258	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57166	57259	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57169,7 +57262,7 @@
57169	57262	state.addr = 23446349213393492LLU; // ASSERTINIT
57170	57263	break;
57171	57264	}
57172		- case 18446744073709549207LLU: // 99999999ZW'''''''''''''''
	57265	+ case 18446744073709549205LLU: // 99999999ZU'''''''''''''''
57173	57266	{
57174	57267	{
57175	57268	uint64_t arg = 0;

		@@ -57248,7 +57341,7 @@
57248	57341	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57249	57342	}
57250	57343	// ACCUMULATE ARGUMENTS - END
57251		- uint64_t return_to = 18446744073709549206LLU;
	57344	+ uint64_t return_to = 18446744073709549204LLU;
57252	57345	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
57253	57346	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57254	57347	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57257,7 +57350,7 @@
57257	57350	state.addr = 293363126232490310LLU; // PROCVARREF
57258	57351	break;
57259	57352	}
57260		- case 18446744073709549206LLU: // 99999999ZV'''''''''''''''
	57353	+ case 18446744073709549204LLU: // 99999999ZT'''''''''''''''
57261	57354	{
57262	57355	// variable u64 initialize goes out of scope
57263	57356	// emitted destructur for type u64

		@@ -57278,7 +57371,7 @@
57278	57371	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57279	57372	}
57280	57373	// ACCUMULATE ARGUMENTS - END
57281		- uint64_t return_to = 18446744073709549205LLU;
	57374	+ uint64_t return_to = 18446744073709549203LLU;
57282	57375	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
57283	57376	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57284	57377	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57287,7 +57380,7 @@
57287	57380	state.addr = 517555565476695680LLU; // assertu64_
57288	57381	break;
57289	57382	}
57290		- case 18446744073709549205LLU: // 99999999ZU'''''''''''''''
	57383	+ case 18446744073709549203LLU: // 99999999ZS'''''''''''''''
57291	57384	{
57292	57385	// ACCUMULATE ARGUMENTS - BEGIN
57293	57386	{

		@@ -57295,7 +57388,7 @@
57295	57388	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57296	57389	}
57297	57390	// ACCUMULATE ARGUMENTS - END
57298		- uint64_t return_to = 18446744073709549204LLU;
	57391	+ uint64_t return_to = 18446744073709549202LLU;
57299	57392	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
57300	57393	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57301	57394	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57304,7 +57397,7 @@
57304	57397	state.addr = 839519665163075584LLU; // skip______
57305	57398	break;
57306	57399	}
57307		- case 18446744073709549204LLU: // 99999999ZT'''''''''''''''
	57400	+ case 18446744073709549202LLU: // 99999999ZR'''''''''''''''
57308	57401	{
57309	57402	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));
57310	57403	fprintf(stdout, "%s", " > ");

		@@ -57314,7 +57407,7 @@
57314	57407	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57315	57408	}
57316	57409	// ACCUMULATE ARGUMENTS - END
57317		- uint64_t return_to = 18446744073709549203LLU;
	57410	+ uint64_t return_to = 18446744073709549201LLU;
57318	57411	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
57319	57412	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57320	57413	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57323,7 +57416,7 @@
57323	57416	state.addr = 839519665163075584LLU; // skip______
57324	57417	break;
57325	57418	}
57326		- case 18446744073709549203LLU: // 99999999ZS'''''''''''''''
	57419	+ case 18446744073709549201LLU: // 99999999ZQ'''''''''''''''
57327	57420	{
57328	57421
57329	57422	LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU)));

		@@ -57345,7 +57438,7 @@
57345	57438	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57346	57439	}
57347	57440	// ACCUMULATE ARGUMENTS - END
57348		- uint64_t return_to = 18446744073709549202LLU;
	57441	+ uint64_t return_to = 18446744073709549200LLU;
57349	57442	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
57350	57443	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57351	57444	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57354,7 +57447,7 @@
57354	57447	state.addr = 23446349213393492LLU; // ASSERTINIT
57355	57448	break;
57356	57449	}
57357		- case 18446744073709549202LLU: // 99999999ZR'''''''''''''''
	57450	+ case 18446744073709549200LLU: // 99999999ZP'''''''''''''''
57358	57451	{
57359	57452	{
57360	57453	uint64_t arg = 0;

		@@ -57433,7 +57526,7 @@
57433	57526	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
57434	57527	}
57435	57528	// ACCUMULATE ARGUMENTS - END
57436		- uint64_t return_to = 18446744073709549201LLU;
	57529	+ uint64_t return_to = 18446744073709549199LLU;
57437	57530	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
57438	57531	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
57439	57532	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -57442,7 +57535,7 @@
57442	57535	state.addr = 293363126232490310LLU; // PROCVARREF
57443	57536	break;
57444	57537	}
57445		- case 18446744073709549201LLU: // 99999999ZQ'''''''''''''''
	57538	+ case 18446744073709549199LLU: // 99999999ZO'''''''''''''''
57446	57539	{
57447	57540

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

Show on old repository browser