OSDN > 浏览软件 > Software Development > Compilers > JPL > SCM > SVN > 提交

JPL

R/O
SSH
HTTPS

jpl: 提交

Commit MetaInfo

修订版	1002 (tree)
时间	2020-05-02 06:27:24
作者	jakobthomsen

Log Message

remove explicit produce annotation obsolete by implicit produce via return/result

更改概述

差异

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

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

		@@ -2957,24 +2957,11 @@
2957	2957	}
2958	2958	break;
2959	2959	}
2960		- case 18446744073709551511LLU: // 999999998W'''''''''''''''
2961		- {
2962		- // destructor for variant produce___
2963		- // RELEASE destructor-argument
2964		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 1
2965		- {
2966		- uint64_t baseinfo = heap.data[0].elem1;
2967		- struct pair pair = unpair(&heap, &baseinfo);
2968		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
2969		- state.addr = pair.elem1;
2970		- }
2971		- break;
2972		- }
2973	2960	case 18446744073709551514LLU: // 999999998Z'''''''''''''''
2974	2961	{
2975	2962	struct pair type_data = unpair(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2976	2963	access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
2977		- state.addr = 18446744073709551511LLU + type_data.elem0;
	2964	+ state.addr = 18446744073709551512LLU + type_data.elem0;
2978	2965	break;
2979	2966	}
2980	2967	case 728618437845356544LLU: // maintain__

		@@ -2985,7 +2972,7 @@
2985	2972	// copy references
2986	2973	// release parameters
2987	2974	{
2988		- uint64_t constridx = 2LLU;
	2975	+ uint64_t constridx = 1LLU;
2989	2976	uint64_t root = pair_move(&heap, &constridx, &result_tuple);
2990	2977	access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/memory root*/)) = root;
2991	2978	}

		@@ -3006,27 +2993,6 @@
3006	2993	// copy references
3007	2994	// release parameters
3008	2995	{
3009		- uint64_t constridx = 1LLU;
3010		- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3011		- access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/memory root*/)) = root;
3012		- }
3013		- }
3014		- {
3015		- uint64_t baseinfo = heap.data[0].elem1;
3016		- struct pair pair = unpair(&heap, &baseinfo);
3017		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3018		- state.addr = pair.elem1;
3019		- }
3020		- break;
3021		- }
3022		- case 787472410168262656LLU: // produce___
3023		- {
3024		- // union-constructor produce___
3025		- {
3026		- uint64_t result_tuple = 0;
3027		- // copy references
3028		- // release parameters
3029		- {
3030	2996	uint64_t constridx = 0LLU;
3031	2997	uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3032	2998	access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/memory root*/)) = root;

		@@ -3042,9 +3008,9 @@
3042	3008	}
3043	3009	case 589058781102643104LLU: // equbalance
3044	3010	{
3045		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/produce___/)
	3011	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/consume___/)
3046	3012	{
3047		- state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
	3013	+ state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
3048	3014	break;
3049	3015	}
3050	3016	{

		@@ -3051,10 +3017,10 @@
3051	3017	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3052	3018	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3053	3019	}
3054		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/produce___/)
	3020	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/consume___/)
3055	3021	{
3056	3022	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3057		- state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
	3023	+ state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
3058	3024	break;
3059	3025	}
3060	3026	{

		@@ -3079,11 +3045,11 @@
3079	3045	}
3080	3046	break;
3081	3047	}
3082		- case 18446744073709551510LLU: // 999999998V'''''''''''''''
	3048	+ case 18446744073709551511LLU: // 999999998W'''''''''''''''
3083	3049	{
3084		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/consume___/)
	3050	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/maintain__/)
3085	3051	{
3086		- state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
	3052	+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3087	3053	break;
3088	3054	}
3089	3055	{

		@@ -3090,10 +3056,10 @@
3090	3056	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3091	3057	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3092	3058	}
3093		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/produce___/)
	3059	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/consume___/)
3094	3060	{
3095	3061	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3096		- state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
	3062	+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3097	3063	break;
3098	3064	}
3099	3065	{

		@@ -3118,11 +3084,11 @@
3118	3084	}
3119	3085	break;
3120	3086	}
3121		- case 18446744073709551509LLU: // 999999998U'''''''''''''''
	3087	+ case 18446744073709551510LLU: // 999999998V'''''''''''''''
3122	3088	{
3123		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/maintain__/)
	3089	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/consume___/)
3124	3090	{
3125		- state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
	3091	+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3126	3092	break;
3127	3093	}
3128	3094	{

		@@ -3129,10 +3095,10 @@
3129	3095	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3130	3096	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3131	3097	}
3132		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/produce___/)
	3098	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/maintain__/)
3133	3099	{
3134	3100	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3135		- state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
	3101	+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3136	3102	break;
3137	3103	}
3138	3104	{

		@@ -3157,11 +3123,11 @@
3157	3123	}
3158	3124	break;
3159	3125	}
3160		- case 18446744073709551508LLU: // 999999998T'''''''''''''''
	3126	+ case 18446744073709551509LLU: // 999999998U'''''''''''''''
3161	3127	{
3162		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/produce___/)
	3128	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/maintain__/)
3163	3129	{
3164		- state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
	3130	+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3165	3131	break;
3166	3132	}
3167	3133	{

		@@ -3168,10 +3134,10 @@
3168	3134	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3169	3135	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3170	3136	}
3171		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/consume___/)
	3137	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/maintain__/)
3172	3138	{
3173	3139	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3174		- state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
	3140	+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3175	3141	break;
3176	3142	}
3177	3143	{

		@@ -3178,45 +3144,6 @@
3178	3144	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3179	3145	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3180	3146	}
3181		- access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3182		- // parameter-reference continuity __________ goes out of scope
3183		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5
3184		- // parameter continuity __________ goes out of scope
3185		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 4
3186		- // parameter-reference continuity __________ goes out of scope
3187		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3188		- // parameter continuity __________ goes out of scope
3189		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3190		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3191		- {
3192		- uint64_t baseinfo = heap.data[0].elem1;
3193		- struct pair pair = unpair(&heap, &baseinfo);
3194		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3195		- state.addr = pair.elem1;
3196		- }
3197		- break;
3198		- }
3199		- case 18446744073709551507LLU: // 999999998S'''''''''''''''
3200		- {
3201		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/consume___/)
3202		- {
3203		- state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3204		- break;
3205		- }
3206		- {
3207		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3208		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3209		- }
3210		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/consume___/)
3211		- {
3212		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3213		- state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3214		- break;
3215		- }
3216		- {
3217		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3218		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3219		- }
3220	3147	access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3221	3148	// parameter-reference continuity __________ goes out of scope
3222	3149	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5

		@@ -3235,164 +3162,8 @@
3235	3162	}
3236	3163	break;
3237	3164	}
3238		- case 18446744073709551506LLU: // 999999998R'''''''''''''''
	3165	+ case 18446744073709551508LLU: // 999999998T'''''''''''''''
3239	3166	{
3240		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/maintain__/)
3241		- {
3242		- state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3243		- break;
3244		- }
3245		- {
3246		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3247		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3248		- }
3249		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/consume___/)
3250		- {
3251		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3252		- state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3253		- break;
3254		- }
3255		- {
3256		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3257		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3258		- }
3259		- access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3260		- // parameter-reference continuity __________ goes out of scope
3261		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5
3262		- // parameter continuity __________ goes out of scope
3263		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 4
3264		- // parameter-reference continuity __________ goes out of scope
3265		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3266		- // parameter continuity __________ goes out of scope
3267		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3268		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3269		- {
3270		- uint64_t baseinfo = heap.data[0].elem1;
3271		- struct pair pair = unpair(&heap, &baseinfo);
3272		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3273		- state.addr = pair.elem1;
3274		- }
3275		- break;
3276		- }
3277		- case 18446744073709551505LLU: // 999999998Q'''''''''''''''
3278		- {
3279		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/produce___/)
3280		- {
3281		- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3282		- break;
3283		- }
3284		- {
3285		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3286		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3287		- }
3288		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/maintain__/)
3289		- {
3290		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3291		- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3292		- break;
3293		- }
3294		- {
3295		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3296		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3297		- }
3298		- access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3299		- // parameter-reference continuity __________ goes out of scope
3300		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5
3301		- // parameter continuity __________ goes out of scope
3302		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 4
3303		- // parameter-reference continuity __________ goes out of scope
3304		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3305		- // parameter continuity __________ goes out of scope
3306		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3307		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3308		- {
3309		- uint64_t baseinfo = heap.data[0].elem1;
3310		- struct pair pair = unpair(&heap, &baseinfo);
3311		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3312		- state.addr = pair.elem1;
3313		- }
3314		- break;
3315		- }
3316		- case 18446744073709551504LLU: // 999999998P'''''''''''''''
3317		- {
3318		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/consume___/)
3319		- {
3320		- state.addr = 18446744073709551503LLU; // 999999998O'''''''''''''''
3321		- break;
3322		- }
3323		- {
3324		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3325		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3326		- }
3327		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/maintain__/)
3328		- {
3329		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3330		- state.addr = 18446744073709551503LLU; // 999999998O'''''''''''''''
3331		- break;
3332		- }
3333		- {
3334		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3335		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3336		- }
3337		- access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3338		- // parameter-reference continuity __________ goes out of scope
3339		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5
3340		- // parameter continuity __________ goes out of scope
3341		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 4
3342		- // parameter-reference continuity __________ goes out of scope
3343		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3344		- // parameter continuity __________ goes out of scope
3345		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3346		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3347		- {
3348		- uint64_t baseinfo = heap.data[0].elem1;
3349		- struct pair pair = unpair(&heap, &baseinfo);
3350		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3351		- state.addr = pair.elem1;
3352		- }
3353		- break;
3354		- }
3355		- case 18446744073709551503LLU: // 999999998O'''''''''''''''
3356		- {
3357		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/maintain__/)
3358		- {
3359		- state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
3360		- break;
3361		- }
3362		- {
3363		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3364		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
3365		- }
3366		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/maintain__/)
3367		- {
3368		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
3369		- state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
3370		- break;
3371		- }
3372		- {
3373		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3374		- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
3375		- }
3376		- access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3377		- // parameter-reference continuity __________ goes out of scope
3378		- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 5
3379		- // parameter continuity __________ goes out of scope
3380		- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 4
3381		- // parameter-reference continuity __________ goes out of scope
3382		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3383		- // parameter continuity __________ goes out of scope
3384		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3385		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3386		- {
3387		- uint64_t baseinfo = heap.data[0].elem1;
3388		- struct pair pair = unpair(&heap, &baseinfo);
3389		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3390		- state.addr = pair.elem1;
3391		- }
3392		- break;
3393		- }
3394		- case 18446744073709551502LLU: // 999999998N'''''''''''''''
3395		- {
3396	3167	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equbalance\n");
3397	3168	exit(-1);
3398	3169	break;

		@@ -3399,9 +3170,9 @@
3399	3170	}
3400	3171	case 58555672873677120LLU: // CPBALANCE_
3401	3172	{
3402		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/produce___/)
	3173	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/consume___/)
3403	3174	{
3404		- state.addr = 18446744073709551501LLU; // 999999998M'''''''''''''''
	3175	+ state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
3405	3176	break;
3406	3177	}
3407	3178	{

		@@ -3414,57 +3185,16 @@
3414	3185	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3415	3186	}
3416	3187	// ACCUMULATE ARGUMENTS - END
3417		- uint64_t return_to = 18446744073709551500LLU;
	3188	+ uint64_t return_to = 18446744073709551506LLU;
3418	3189	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
3419	3190	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3420	3191	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3421	3192	heap.data[0].elem1 = heap.data[0].elem0;
3422	3193	heap.data[0].elem0 = restore;
3423		- state.addr = 787472410168262656LLU; // produce___
3424		- break;
3425		- }
3426		- case 18446744073709551500LLU: // 999999998L'''''''''''''''
3427		- {
3428		- // parameter-reference continuity __________ goes out of scope
3429		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3
3430		- // parameter continuity __________ goes out of scope
3431		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
3432		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
3433		- {
3434		- uint64_t baseinfo = heap.data[0].elem1;
3435		- struct pair pair = unpair(&heap, &baseinfo);
3436		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
3437		- state.addr = pair.elem1;
3438		- }
3439		- break;
3440		- }
3441		- case 18446744073709551501LLU: // 999999998M'''''''''''''''
3442		- {
3443		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/consume___/)
3444		- {
3445		- state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
3446		- break;
3447		- }
3448		- {
3449		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3450		- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
3451		- }
3452		- // ACCUMULATE ARGUMENTS - BEGIN
3453		- {
3454		- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3455		- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3456		- }
3457		- // ACCUMULATE ARGUMENTS - END
3458		- uint64_t return_to = 18446744073709551498LLU;
3459		- const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
3460		- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3461		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3462		- heap.data[0].elem1 = heap.data[0].elem0;
3463		- heap.data[0].elem0 = restore;
3464	3194	state.addr = 552437437528276992LLU; // consume___
3465	3195	break;
3466	3196	}
3467		- case 18446744073709551498LLU: // 999999998J'''''''''''''''
	3197	+ case 18446744073709551506LLU: // 999999998R'''''''''''''''
3468	3198	{
3469	3199	// parameter-reference continuity __________ goes out of scope
3470	3200	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3

		@@ -3479,11 +3209,11 @@
3479	3209	}
3480	3210	break;
3481	3211	}
3482		- case 18446744073709551499LLU: // 999999998K'''''''''''''''
	3212	+ case 18446744073709551507LLU: // 999999998S'''''''''''''''
3483	3213	{
3484		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/maintain__/)
	3214	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/maintain__/)
3485	3215	{
3486		- state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
	3216	+ state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3487	3217	break;
3488	3218	}
3489	3219	{

		@@ -3496,7 +3226,7 @@
3496	3226	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3497	3227	}
3498	3228	// ACCUMULATE ARGUMENTS - END
3499		- uint64_t return_to = 18446744073709551496LLU;
	3229	+ uint64_t return_to = 18446744073709551504LLU;
3500	3230	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
3501	3231	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3502	3232	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -3505,7 +3235,7 @@
3505	3235	state.addr = 728618437845356544LLU; // maintain__
3506	3236	break;
3507	3237	}
3508		- case 18446744073709551496LLU: // 999999998H'''''''''''''''
	3238	+ case 18446744073709551504LLU: // 999999998P'''''''''''''''
3509	3239	{
3510	3240	// parameter-reference continuity __________ goes out of scope
3511	3241	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 3

		@@ -3520,13 +3250,13 @@
3520	3250	}
3521	3251	break;
3522	3252	}
3523		- case 18446744073709551497LLU: // 999999998I'''''''''''''''
	3253	+ case 18446744073709551505LLU: // 999999998Q'''''''''''''''
3524	3254	{
3525	3255	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CPBALANCE_\n");
3526	3256	exit(-1);
3527	3257	break;
3528	3258	}
3529		- case 18446744073709551494LLU: // 999999998F'''''''''''''''
	3259	+ case 18446744073709551502LLU: // 999999998N'''''''''''''''
3530	3260	{
3531	3261	// destructor for variant blkloop___
3532	3262	// RELEASE destructor-argument

		@@ -3539,7 +3269,7 @@
3539	3269	}
3540	3270	break;
3541	3271	}
3542		- case 18446744073709551493LLU: // 999999998E'''''''''''''''
	3272	+ case 18446744073709551501LLU: // 999999998M'''''''''''''''
3543	3273	{
3544	3274	// destructor for variant blkelse___
3545	3275	// RELEASE destructor-argument

		@@ -3552,7 +3282,7 @@
3552	3282	}
3553	3283	break;
3554	3284	}
3555		- case 18446744073709551492LLU: // 999999998D'''''''''''''''
	3285	+ case 18446744073709551500LLU: // 999999998L'''''''''''''''
3556	3286	{
3557	3287	// destructor for variant blkif_____
3558	3288	// RELEASE destructor-argument

		@@ -3565,7 +3295,7 @@
3565	3295	}
3566	3296	break;
3567	3297	}
3568		- case 18446744073709551491LLU: // 999999998C'''''''''''''''
	3298	+ case 18446744073709551499LLU: // 999999998K'''''''''''''''
3569	3299	{
3570	3300	// destructor for variant blkwhen___
3571	3301	// RELEASE destructor-argument

		@@ -3578,7 +3308,7 @@
3578	3308	}
3579	3309	break;
3580	3310	}
3581		- case 18446744073709551490LLU: // 999999998B'''''''''''''''
	3311	+ case 18446744073709551498LLU: // 999999998J'''''''''''''''
3582	3312	{
3583	3313	// destructor for variant blknone___
3584	3314	// RELEASE destructor-argument

		@@ -3591,11 +3321,11 @@
3591	3321	}
3592	3322	break;
3593	3323	}
3594		- case 18446744073709551495LLU: // 999999998G'''''''''''''''
	3324	+ case 18446744073709551503LLU: // 999999998O'''''''''''''''
3595	3325	{
3596	3326	struct pair type_data = unpair(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3597	3327	access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
3598		- state.addr = 18446744073709551490LLU + type_data.elem0;
	3328	+ state.addr = 18446744073709551498LLU + type_data.elem0;
3599	3329	break;
3600	3330	}
3601	3331	case 533564932506779648LLU: // blkloop___

		@@ -3707,7 +3437,7 @@
3707	3437	{
3708	3438	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/blknone___/)
3709	3439	{
3710		- state.addr = 18446744073709551489LLU; // 999999998A'''''''''''''''
	3440	+ state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
3711	3441	break;
3712	3442	}
3713	3443	{

		@@ -3727,11 +3457,11 @@
3727	3457	}
3728	3458	break;
3729	3459	}
3730		- case 18446744073709551489LLU: // 999999998A'''''''''''''''
	3460	+ case 18446744073709551497LLU: // 999999998I'''''''''''''''
3731	3461	{
3732	3462	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/blkwhen___/)
3733	3463	{
3734		- state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
	3464	+ state.addr = 18446744073709551496LLU; // 999999998H'''''''''''''''
3735	3465	break;
3736	3466	}
3737	3467	{

		@@ -3751,11 +3481,11 @@
3751	3481	}
3752	3482	break;
3753	3483	}
3754		- case 18446744073709551488LLU: // 999999998_'''''''''''''''
	3484	+ case 18446744073709551496LLU: // 999999998H'''''''''''''''
3755	3485	{
3756	3486	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/blkif_____/)
3757	3487	{
3758		- state.addr = 18446744073709551487LLU; // 9999999979'''''''''''''''
	3488	+ state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
3759	3489	break;
3760	3490	}
3761	3491	{

		@@ -3775,11 +3505,11 @@
3775	3505	}
3776	3506	break;
3777	3507	}
3778		- case 18446744073709551487LLU: // 9999999979'''''''''''''''
	3508	+ case 18446744073709551495LLU: // 999999998G'''''''''''''''
3779	3509	{
3780	3510	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/blkelse___/)
3781	3511	{
3782		- state.addr = 18446744073709551486LLU; // 9999999978'''''''''''''''
	3512	+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
3783	3513	break;
3784	3514	}
3785	3515	{

		@@ -3799,11 +3529,11 @@
3799	3529	}
3800	3530	break;
3801	3531	}
3802		- case 18446744073709551486LLU: // 9999999978'''''''''''''''
	3532	+ case 18446744073709551494LLU: // 999999998F'''''''''''''''
3803	3533	{
3804	3534	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/blkloop___/)
3805	3535	{
3806		- state.addr = 18446744073709551485LLU; // 9999999977'''''''''''''''
	3536	+ state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
3807	3537	break;
3808	3538	}
3809	3539	{

		@@ -3823,13 +3553,13 @@
3823	3553	}
3824	3554	break;
3825	3555	}
3826		- case 18446744073709551485LLU: // 9999999977'''''''''''''''
	3556	+ case 18446744073709551493LLU: // 999999998E'''''''''''''''
3827	3557	{
3828	3558	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportblk_\n");
3829	3559	exit(-1);
3830	3560	break;
3831	3561	}
3832		- case 18446744073709551483LLU: // 9999999975'''''''''''''''
	3562	+ case 18446744073709551491LLU: // 999999998C'''''''''''''''
3833	3563	{
3834	3564	// destructor for variant varhide___
3835	3565	// RELEASE destructor-argument

		@@ -3842,7 +3572,7 @@
3842	3572	}
3843	3573	break;
3844	3574	}
3845		- case 18446744073709551482LLU: // 9999999974'''''''''''''''
	3575	+ case 18446744073709551490LLU: // 999999998B'''''''''''''''
3846	3576	{
3847	3577	// destructor for variant elblock___
3848	3578	{

		@@ -3862,7 +3592,7 @@
3862	3592	}
3863	3593	break;
3864	3594	}
3865		- case 18446744073709551481LLU: // 9999999973'''''''''''''''
	3595	+ case 18446744073709551489LLU: // 999999998A'''''''''''''''
3866	3596	{
3867	3597	// destructor for variant varblock__
3868	3598	// RELEASE destructor-argument

		@@ -3875,7 +3605,7 @@
3875	3605	}
3876	3606	break;
3877	3607	}
3878		- case 18446744073709551480LLU: // 9999999972'''''''''''''''
	3608	+ case 18446744073709551488LLU: // 999999998_'''''''''''''''
3879	3609	{
3880	3610	// destructor for variant varvirt___
3881	3611	{

		@@ -3903,7 +3633,7 @@
3903	3633	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3904	3634	}
3905	3635	// ACCUMULATE ARGUMENTS - END
3906		- uint64_t return_to = 18446744073709551477LLU;
	3636	+ uint64_t return_to = 18446744073709551485LLU;
3907	3637	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
3908	3638	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3909	3639	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -3912,7 +3642,7 @@
3912	3642	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3913	3643	break;
3914	3644	}
3915		- case 18446744073709551477LLU: // 999999997z'''''''''''''''
	3645	+ case 18446744073709551485LLU: // 9999999977'''''''''''''''
3916	3646	{
3917	3647	// RELEASE temporary destructor-variable
3918	3648	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -3940,7 +3670,7 @@
3940	3670	}
3941	3671	break;
3942	3672	}
3943		- case 18446744073709551479LLU: // 9999999971'''''''''''''''
	3673	+ case 18446744073709551487LLU: // 9999999979'''''''''''''''
3944	3674	{
3945	3675	// destructor for variant varref____
3946	3676	{

		@@ -3975,7 +3705,7 @@
3975	3705	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3976	3706	}
3977	3707	// ACCUMULATE ARGUMENTS - END
3978		- uint64_t return_to = 18446744073709551476LLU;
	3708	+ uint64_t return_to = 18446744073709551484LLU;
3979	3709	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
3980	3710	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3981	3711	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -3984,7 +3714,7 @@
3984	3714	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3985	3715	break;
3986	3716	}
3987		- case 18446744073709551476LLU: // 999999997y'''''''''''''''
	3717	+ case 18446744073709551484LLU: // 9999999976'''''''''''''''
3988	3718	{
3989	3719	// RELEASE temporary destructor-variable
3990	3720	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4012,7 +3742,7 @@
4012	3742	}
4013	3743	break;
4014	3744	}
4015		- case 18446744073709551478LLU: // 9999999970'''''''''''''''
	3745	+ case 18446744073709551486LLU: // 9999999978'''''''''''''''
4016	3746	{
4017	3747	// destructor for variant varvar____
4018	3748	{

		@@ -4040,7 +3770,7 @@
4040	3770	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4041	3771	}
4042	3772	// ACCUMULATE ARGUMENTS - END
4043		- uint64_t return_to = 18446744073709551475LLU;
	3773	+ uint64_t return_to = 18446744073709551483LLU;
4044	3774	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4045	3775	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4046	3776	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4049,7 +3779,7 @@
4049	3779	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4050	3780	break;
4051	3781	}
4052		- case 18446744073709551475LLU: // 999999997x'''''''''''''''
	3782	+ case 18446744073709551483LLU: // 9999999975'''''''''''''''
4053	3783	{
4054	3784	// RELEASE temporary destructor-variable
4055	3785	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4077,11 +3807,11 @@
4077	3807	}
4078	3808	break;
4079	3809	}
4080		- case 18446744073709551484LLU: // 9999999976'''''''''''''''
	3810	+ case 18446744073709551492LLU: // 999999998D'''''''''''''''
4081	3811	{
4082	3812	struct pair type_data = unpair(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4083	3813	access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
4084		- state.addr = 18446744073709551478LLU + type_data.elem0;
	3814	+ state.addr = 18446744073709551486LLU + type_data.elem0;
4085	3815	break;
4086	3816	}
4087	3817	case 890787182770388992LLU: // varhide___

		@@ -4333,7 +4063,7 @@
4333	4063	{
4334	4064	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/varvar____/)
4335	4065	{
4336		- state.addr = 18446744073709551474LLU; // 999999997w'''''''''''''''
	4066	+ state.addr = 18446744073709551482LLU; // 9999999974'''''''''''''''
4337	4067	break;
4338	4068	}
4339	4069	{

		@@ -4353,11 +4083,11 @@
4353	4083	}
4354	4084	break;
4355	4085	}
4356		- case 18446744073709551474LLU: // 999999997w'''''''''''''''
	4086	+ case 18446744073709551482LLU: // 9999999974'''''''''''''''
4357	4087	{
4358	4088	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/varref____/)
4359	4089	{
4360		- state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
	4090	+ state.addr = 18446744073709551481LLU; // 9999999973'''''''''''''''
4361	4091	break;
4362	4092	}
4363	4093	{

		@@ -4377,11 +4107,11 @@
4377	4107	}
4378	4108	break;
4379	4109	}
4380		- case 18446744073709551473LLU: // 999999997v'''''''''''''''
	4110	+ case 18446744073709551481LLU: // 9999999973'''''''''''''''
4381	4111	{
4382	4112	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/varvirt___/)
4383	4113	{
4384		- state.addr = 18446744073709551472LLU; // 999999997u'''''''''''''''
	4114	+ state.addr = 18446744073709551480LLU; // 9999999972'''''''''''''''
4385	4115	break;
4386	4116	}
4387	4117	{

		@@ -4401,11 +4131,11 @@
4401	4131	}
4402	4132	break;
4403	4133	}
4404		- case 18446744073709551472LLU: // 999999997u'''''''''''''''
	4134	+ case 18446744073709551480LLU: // 9999999972'''''''''''''''
4405	4135	{
4406	4136	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/varblock__/)
4407	4137	{
4408		- state.addr = 18446744073709551471LLU; // 999999997t'''''''''''''''
	4138	+ state.addr = 18446744073709551479LLU; // 9999999971'''''''''''''''
4409	4139	break;
4410	4140	}
4411	4141	{

		@@ -4425,11 +4155,11 @@
4425	4155	}
4426	4156	break;
4427	4157	}
4428		- case 18446744073709551471LLU: // 999999997t'''''''''''''''
	4158	+ case 18446744073709551479LLU: // 9999999971'''''''''''''''
4429	4159	{
4430	4160	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/elblock___/)
4431	4161	{
4432		- state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
	4162	+ state.addr = 18446744073709551478LLU; // 9999999970'''''''''''''''
4433	4163	break;
4434	4164	}
4435	4165	{

		@@ -4449,11 +4179,11 @@
4449	4179	}
4450	4180	break;
4451	4181	}
4452		- case 18446744073709551470LLU: // 999999997s'''''''''''''''
	4182	+ case 18446744073709551478LLU: // 9999999970'''''''''''''''
4453	4183	{
4454	4184	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 5/varhide___/)
4455	4185	{
4456		- state.addr = 18446744073709551469LLU; // 999999997r'''''''''''''''
	4186	+ state.addr = 18446744073709551477LLU; // 999999997z'''''''''''''''
4457	4187	break;
4458	4188	}
4459	4189	{

		@@ -4473,13 +4203,13 @@
4473	4203	}
4474	4204	break;
4475	4205	}
4476		- case 18446744073709551469LLU: // 999999997r'''''''''''''''
	4206	+ case 18446744073709551477LLU: // 999999997z'''''''''''''''
4477	4207	{
4478	4208	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportvar_\n");
4479	4209	exit(-1);
4480	4210	break;
4481	4211	}
4482		- case 18446744073709551468LLU: // 999999997q'''''''''''''''
	4212	+ case 18446744073709551476LLU: // 999999997y'''''''''''''''
4483	4213	{
4484	4214	{
4485	4215	uint64_t arg = tree_pop_move(&heap, 4LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -4499,7 +4229,7 @@
4499	4229	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4500	4230	}
4501	4231	// ACCUMULATE ARGUMENTS - END
4502		- uint64_t return_to = 18446744073709551467LLU;
	4232	+ uint64_t return_to = 18446744073709551475LLU;
4503	4233	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4504	4234	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4505	4235	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4508,7 +4238,7 @@
4508	4238	state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4509	4239	break;
4510	4240	}
4511		- case 18446744073709551467LLU: // 999999997p'''''''''''''''
	4241	+ case 18446744073709551475LLU: // 999999997x'''''''''''''''
4512	4242	{
4513	4243	// RELEASE temporary destructor-variable
4514	4244	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4530,7 +4260,7 @@
4530	4260	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4531	4261	}
4532	4262	// ACCUMULATE ARGUMENTS - END
4533		- uint64_t return_to = 18446744073709551466LLU;
	4263	+ uint64_t return_to = 18446744073709551474LLU;
4534	4264	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4535	4265	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4536	4266	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4539,7 +4269,7 @@
4539	4269	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4540	4270	break;
4541	4271	}
4542		- case 18446744073709551466LLU: // 999999997o'''''''''''''''
	4272	+ case 18446744073709551474LLU: // 999999997w'''''''''''''''
4543	4273	{
4544	4274	// RELEASE temporary destructor-variable
4545	4275	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4598,7 +4328,7 @@
4598	4328	}
4599	4329	break;
4600	4330	}
4601		- case 18446744073709551465LLU: // 999999997n'''''''''''''''
	4331	+ case 18446744073709551473LLU: // 999999997v'''''''''''''''
4602	4332	{
4603	4333	{
4604	4334	uint64_t arg = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -4611,7 +4341,7 @@
4611	4341	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4612	4342	}
4613	4343	// ACCUMULATE ARGUMENTS - END
4614		- uint64_t return_to = 18446744073709551464LLU;
	4344	+ uint64_t return_to = 18446744073709551472LLU;
4615	4345	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4616	4346	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4617	4347	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4620,7 +4350,7 @@
4620	4350	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4621	4351	break;
4622	4352	}
4623		- case 18446744073709551464LLU: // 999999997m'''''''''''''''
	4353	+ case 18446744073709551472LLU: // 999999997u'''''''''''''''
4624	4354	{
4625	4355	// RELEASE temporary destructor-variable
4626	4356	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4672,7 +4402,7 @@
4672	4402	}
4673	4403	break;
4674	4404	}
4675		- case 18446744073709551463LLU: // 999999997l'''''''''''''''
	4405	+ case 18446744073709551471LLU: // 999999997t'''''''''''''''
4676	4406	{
4677	4407	{
4678	4408	uint64_t arg = tree_pop_move(&heap, 5LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -4692,7 +4422,7 @@
4692	4422	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4693	4423	}
4694	4424	// ACCUMULATE ARGUMENTS - END
4695		- uint64_t return_to = 18446744073709551462LLU;
	4425	+ uint64_t return_to = 18446744073709551470LLU;
4696	4426	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4697	4427	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4698	4428	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4701,7 +4431,7 @@
4701	4431	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4702	4432	break;
4703	4433	}
4704		- case 18446744073709551462LLU: // 999999997k'''''''''''''''
	4434	+ case 18446744073709551470LLU: // 999999997s'''''''''''''''
4705	4435	{
4706	4436	// RELEASE temporary destructor-variable
4707	4437	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4723,7 +4453,7 @@
4723	4453	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4724	4454	}
4725	4455	// ACCUMULATE ARGUMENTS - END
4726		- uint64_t return_to = 18446744073709551461LLU;
	4456	+ uint64_t return_to = 18446744073709551469LLU;
4727	4457	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4728	4458	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4729	4459	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4732,7 +4462,7 @@
4732	4462	state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4733	4463	break;
4734	4464	}
4735		- case 18446744073709551461LLU: // 999999997j'''''''''''''''
	4465	+ case 18446744073709551469LLU: // 999999997r'''''''''''''''
4736	4466	{
4737	4467	// RELEASE temporary destructor-variable
4738	4468	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -4857,7 +4587,7 @@
4857	4587	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4858	4588	}
4859	4589	// ACCUMULATE ARGUMENTS - END
4860		- uint64_t return_to = 18446744073709551459LLU;
	4590	+ uint64_t return_to = 18446744073709551467LLU;
4861	4591	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4862	4592	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4863	4593	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4866,7 +4596,7 @@
4866	4596	state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4867	4597	break;
4868	4598	}
4869		- case 18446744073709551459LLU: // 999999997h'''''''''''''''
	4599	+ case 18446744073709551467LLU: // 999999997p'''''''''''''''
4870	4600	{
4871	4601	// ACCUMULATE ARGUMENTS - BEGIN
4872	4602	{

		@@ -4878,7 +4608,7 @@
4878	4608	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4879	4609	}
4880	4610	// ACCUMULATE ARGUMENTS - END
4881		- uint64_t return_to = 18446744073709551458LLU;
	4611	+ uint64_t return_to = 18446744073709551466LLU;
4882	4612	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
4883	4613	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4884	4614	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4887,7 +4617,7 @@
4887	4617	state.addr = 58555672873677120LLU; // CPBALANCE_
4888	4618	break;
4889	4619	}
4890		- case 18446744073709551458LLU: // 999999997g'''''''''''''''
	4620	+ case 18446744073709551466LLU: // 999999997o'''''''''''''''
4891	4621	{
4892	4622
4893	4623	access_heap(heap.data, LOCAL_ACCESS(heap.data, 12LLU, 4LLU)) = /mutable1__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 12LLU, 9LLU));

		@@ -4899,7 +4629,7 @@
4899	4629	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4900	4630	}
4901	4631	// ACCUMULATE ARGUMENTS - END
4902		- uint64_t return_to = 18446744073709551457LLU;
	4632	+ uint64_t return_to = 18446744073709551465LLU;
4903	4633	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
4904	4634	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4905	4635	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4908,7 +4638,7 @@
4908	4638	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4909	4639	break;
4910	4640	}
4911		- case 18446744073709551457LLU: // 999999997f'''''''''''''''
	4641	+ case 18446744073709551465LLU: // 999999997n'''''''''''''''
4912	4642	{
4913	4643	// ACCUMULATE ARGUMENTS - BEGIN
4914	4644	{

		@@ -4920,7 +4650,7 @@
4920	4650	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4921	4651	}
4922	4652	// ACCUMULATE ARGUMENTS - END
4923		- uint64_t return_to = 18446744073709551456LLU;
	4653	+ uint64_t return_to = 18446744073709551464LLU;
4924	4654	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
4925	4655	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4926	4656	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4929,7 +4659,7 @@
4929	4659	state.addr = 367395560426147840LLU; // TYPECOPY__
4930	4660	break;
4931	4661	}
4932		- case 18446744073709551456LLU: // 999999997e'''''''''''''''
	4662	+ case 18446744073709551464LLU: // 999999997m'''''''''''''''
4933	4663	{
4934	4664
4935	4665	access_heap(heap.data, LOCAL_ACCESS(heap.data, 12LLU, 6LLU)) = /curidx1___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 12LLU, 11LLU));

		@@ -4982,7 +4712,7 @@
4982	4712	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4983	4713	}
4984	4714	// ACCUMULATE ARGUMENTS - END
4985		- uint64_t return_to = 18446744073709551455LLU;
	4715	+ uint64_t return_to = 18446744073709551463LLU;
4986	4716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
4987	4717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4988	4718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -4991,7 +4721,7 @@
4991	4721	state.addr = 589060043891015680LLU; // equtype___
4992	4722	break;
4993	4723	}
4994		- case 18446744073709551455LLU: // 999999997d'''''''''''''''
	4724	+ case 18446744073709551463LLU: // 999999997l'''''''''''''''
4995	4725	{
4996	4726	{
4997	4727	uint64_t arg = 0;

		@@ -4998,22 +4728,22 @@
4998	4728	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
4999	4729	}
5000	4730	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5001		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551454LLU : 18446744073709551453LLU;
	4731	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551462LLU : 18446744073709551461LLU;
5002	4732	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5003	4733	break;
5004	4734	}
5005		- case 18446744073709551454LLU: // 999999997c'''''''''''''''
	4735	+ case 18446744073709551462LLU: // 999999997k'''''''''''''''
5006	4736	{
5007		- state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
	4737	+ state.addr = 18446744073709551460LLU; // 999999997i'''''''''''''''
5008	4738	break;
5009	4739	}
5010		- case 18446744073709551453LLU: // 999999997b'''''''''''''''
	4740	+ case 18446744073709551461LLU: // 999999997j'''''''''''''''
5011	4741	{
5012	4742	fprintf(stderr, "%s", "type");
5013		- state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
	4743	+ state.addr = 18446744073709551460LLU; // 999999997i'''''''''''''''
5014	4744	break;
5015	4745	}
5016		- case 18446744073709551452LLU: // 999999997a'''''''''''''''
	4746	+ case 18446744073709551460LLU: // 999999997i'''''''''''''''
5017	4747	{
5018	4748	{
5019	4749	uint64_t arg = 0;

		@@ -5020,11 +4750,11 @@
5020	4750	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5021	4751	}
5022	4752	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5023		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551451LLU : 18446744073709551450LLU;
	4753	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551459LLU : 18446744073709551458LLU;
5024	4754	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5025	4755	break;
5026	4756	}
5027		- case 18446744073709551451LLU: // 999999997$'''''''''''''''
	4757	+ case 18446744073709551459LLU: // 999999997h'''''''''''''''
5028	4758	{
5029	4759
5030	4760	access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU));

		@@ -5033,22 +4763,22 @@
5033	4763	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5034	4764	}
5035	4765	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5036		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551449LLU : 18446744073709551448LLU;
	4766	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551457LLU : 18446744073709551456LLU;
5037	4767	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5038	4768	break;
5039	4769	}
5040		- case 18446744073709551449LLU: // 999999997Y'''''''''''''''
	4770	+ case 18446744073709551457LLU: // 999999997f'''''''''''''''
5041	4771	{
5042		- state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
	4772	+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
5043	4773	break;
5044	4774	}
5045		- case 18446744073709551448LLU: // 999999997X'''''''''''''''
	4775	+ case 18446744073709551456LLU: // 999999997e'''''''''''''''
5046	4776	{
5047	4777	fprintf(stderr, "%s", "mutable");
5048		- state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
	4778	+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
5049	4779	break;
5050	4780	}
5051		- case 18446744073709551447LLU: // 999999997W'''''''''''''''
	4781	+ case 18446744073709551455LLU: // 999999997d'''''''''''''''
5052	4782	{
5053	4783	{
5054	4784	uint64_t arg = 0;

		@@ -5055,11 +4785,11 @@
5055	4785	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5056	4786	}
5057	4787	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5058		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551446LLU : 18446744073709551445LLU;
	4788	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551454LLU : 18446744073709551453LLU;
5059	4789	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5060	4790	break;
5061	4791	}
5062		- case 18446744073709551446LLU: // 999999997V'''''''''''''''
	4792	+ case 18446744073709551454LLU: // 999999997c'''''''''''''''
5063	4793	{
5064	4794
5065	4795	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -5076,7 +4806,7 @@
5076	4806	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5077	4807	}
5078	4808	// ACCUMULATE ARGUMENTS - END
5079		- uint64_t return_to = 18446744073709551444LLU;
	4809	+ uint64_t return_to = 18446744073709551452LLU;
5080	4810	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
5081	4811	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5082	4812	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5085,7 +4815,7 @@
5085	4815	state.addr = 589058781102643104LLU; // equbalance
5086	4816	break;
5087	4817	}
5088		- case 18446744073709551444LLU: // 999999997T'''''''''''''''
	4818	+ case 18446744073709551452LLU: // 999999997a'''''''''''''''
5089	4819	{
5090	4820	{
5091	4821	uint64_t arg = 0;

		@@ -5092,22 +4822,22 @@
5092	4822	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5093	4823	}
5094	4824	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5095		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551443LLU : 18446744073709551442LLU;
	4825	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551451LLU : 18446744073709551450LLU;
5096	4826	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5097	4827	break;
5098	4828	}
5099		- case 18446744073709551443LLU: // 999999997S'''''''''''''''
	4829	+ case 18446744073709551451LLU: // 999999997$'''''''''''''''
5100	4830	{
5101		- state.addr = 18446744073709551441LLU; // 999999997Q'''''''''''''''
	4831	+ state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
5102	4832	break;
5103	4833	}
5104		- case 18446744073709551442LLU: // 999999997R'''''''''''''''
	4834	+ case 18446744073709551450LLU: // 999999997Z'''''''''''''''
5105	4835	{
5106	4836	fprintf(stderr, "%s", "continuity");
5107		- state.addr = 18446744073709551441LLU; // 999999997Q'''''''''''''''
	4837	+ state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
5108	4838	break;
5109	4839	}
5110		- case 18446744073709551441LLU: // 999999997Q'''''''''''''''
	4840	+ case 18446744073709551449LLU: // 999999997Y'''''''''''''''
5111	4841	{
5112	4842	{
5113	4843	uint64_t arg = 0;

		@@ -5114,11 +4844,11 @@
5114	4844	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5115	4845	}
5116	4846	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5117		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551440LLU : 18446744073709551439LLU;
	4847	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551448LLU : 18446744073709551447LLU;
5118	4848	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5119	4849	break;
5120	4850	}
5121		- case 18446744073709551440LLU: // 999999997P'''''''''''''''
	4851	+ case 18446744073709551448LLU: // 999999997X'''''''''''''''
5122	4852	{
5123	4853
5124	4854	access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 3LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 3LLU));

		@@ -5127,37 +4857,37 @@
5127	4857	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5128	4858	}
5129	4859	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5130		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551438LLU : 18446744073709551437LLU;
	4860	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551446LLU : 18446744073709551445LLU;
5131	4861	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5132	4862	break;
5133	4863	}
5134		- case 18446744073709551438LLU: // 999999997N'''''''''''''''
	4864	+ case 18446744073709551446LLU: // 999999997V'''''''''''''''
5135	4865	{
5136		- state.addr = 18446744073709551436LLU; // 999999997L'''''''''''''''
	4866	+ state.addr = 18446744073709551444LLU; // 999999997T'''''''''''''''
5137	4867	break;
5138	4868	}
5139		- case 18446744073709551437LLU: // 999999997M'''''''''''''''
	4869	+ case 18446744073709551445LLU: // 999999997U'''''''''''''''
5140	4870	{
5141	4871	fprintf(stderr, "%s", "REFERENCE");
5142		- state.addr = 18446744073709551436LLU; // 999999997L'''''''''''''''
	4872	+ state.addr = 18446744073709551444LLU; // 999999997T'''''''''''''''
5143	4873	break;
5144	4874	}
5145		- case 18446744073709551436LLU: // 999999997L'''''''''''''''
	4875	+ case 18446744073709551444LLU: // 999999997T'''''''''''''''
5146	4876	{
5147		- state.addr = 18446744073709551439LLU; // 999999997O'''''''''''''''
	4877	+ state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
5148	4878	break;
5149	4879	}
5150		- case 18446744073709551439LLU: // 999999997O'''''''''''''''
	4880	+ case 18446744073709551447LLU: // 999999997W'''''''''''''''
5151	4881	{
5152		- state.addr = 18446744073709551445LLU; // 999999997U'''''''''''''''
	4882	+ state.addr = 18446744073709551453LLU; // 999999997b'''''''''''''''
5153	4883	break;
5154	4884	}
5155		- case 18446744073709551445LLU: // 999999997U'''''''''''''''
	4885	+ case 18446744073709551453LLU: // 999999997b'''''''''''''''
5156	4886	{
5157		- state.addr = 18446744073709551450LLU; // 999999997Z'''''''''''''''
	4887	+ state.addr = 18446744073709551458LLU; // 999999997g'''''''''''''''
5158	4888	break;
5159	4889	}
5160		- case 18446744073709551450LLU: // 999999997Z'''''''''''''''
	4890	+ case 18446744073709551458LLU: // 999999997g'''''''''''''''
5161	4891	{
5162	4892	// parameter-reference pardef____ y_________ goes out of scope
5163	4893	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3

		@@ -5182,11 +4912,11 @@
5182	4912	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5183	4913	}
5184	4914	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /equal_____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5185		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551435LLU : 18446744073709551434LLU;
	4915	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551443LLU : 18446744073709551442LLU;
5186	4916	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5187	4917	break;
5188	4918	}
5189		- case 18446744073709551435LLU: // 999999997K'''''''''''''''
	4919	+ case 18446744073709551443LLU: // 999999997S'''''''''''''''
5190	4920	{
5191	4921
5192	4922	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -5203,7 +4933,7 @@
5203	4933	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5204	4934	}
5205	4935	// ACCUMULATE ARGUMENTS - END
5206		- uint64_t return_to = 18446744073709551433LLU;
	4936	+ uint64_t return_to = 18446744073709551441LLU;
5207	4937	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
5208	4938	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5209	4939	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5212,12 +4942,12 @@
5212	4942	state.addr = 589060043891015680LLU; // equtype___
5213	4943	break;
5214	4944	}
5215		- case 18446744073709551433LLU: // 999999997I'''''''''''''''
	4945	+ case 18446744073709551441LLU: // 999999997Q'''''''''''''''
5216	4946	{
5217		- state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
	4947	+ state.addr = 18446744073709551442LLU; // 999999997R'''''''''''''''
5218	4948	break;
5219	4949	}
5220		- case 18446744073709551434LLU: // 999999997J'''''''''''''''
	4950	+ case 18446744073709551442LLU: // 999999997R'''''''''''''''
5221	4951	{
5222	4952	// parameter-reference elemdef___ y_________ goes out of scope
5223	4953	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3

		@@ -5275,7 +5005,7 @@
5275	5005	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5276	5006	}
5277	5007	// ACCUMULATE ARGUMENTS - END
5278		- uint64_t return_to = 18446744073709551431LLU;
	5008	+ uint64_t return_to = 18446744073709551439LLU;
5279	5009	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5280	5010	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5281	5011	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5284,7 +5014,7 @@
5284	5014	state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5285	5015	break;
5286	5016	}
5287		- case 18446744073709551431LLU: // 999999997G'''''''''''''''
	5017	+ case 18446744073709551439LLU: // 999999997O'''''''''''''''
5288	5018	{
5289	5019	// ACCUMULATE ARGUMENTS - BEGIN
5290	5020	{

		@@ -5296,7 +5026,7 @@
5296	5026	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5297	5027	}
5298	5028	// ACCUMULATE ARGUMENTS - END
5299		- uint64_t return_to = 18446744073709551430LLU;
	5029	+ uint64_t return_to = 18446744073709551438LLU;
5300	5030	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5301	5031	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5302	5032	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5305,7 +5035,7 @@
5305	5035	state.addr = 367395560426147840LLU; // TYPECOPY__
5306	5036	break;
5307	5037	}
5308		- case 18446744073709551430LLU: // 999999997F'''''''''''''''
	5038	+ case 18446744073709551438LLU: // 999999997N'''''''''''''''
5309	5039	{
5310	5040
5311	5041	// emitted destructur for type continuity

		@@ -5315,7 +5045,7 @@
5315	5045	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5316	5046	}
5317	5047	// ACCUMULATE ARGUMENTS - END
5318		- uint64_t return_to = 18446744073709551429LLU;
	5048	+ uint64_t return_to = 18446744073709551437LLU;
5319	5049	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5320	5050	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5321	5051	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5324,7 +5054,7 @@
5324	5054	state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
5325	5055	break;
5326	5056	}
5327		- case 18446744073709551429LLU: // 999999997E'''''''''''''''
	5057	+ case 18446744073709551437LLU: // 999999997M'''''''''''''''
5328	5058	{
5329	5059	// ACCUMULATE ARGUMENTS - BEGIN
5330	5060	{

		@@ -5336,7 +5066,7 @@
5336	5066	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5337	5067	}
5338	5068	// ACCUMULATE ARGUMENTS - END
5339		- uint64_t return_to = 18446744073709551428LLU;
	5069	+ uint64_t return_to = 18446744073709551436LLU;
5340	5070	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5341	5071	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5342	5072	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5345,7 +5075,7 @@
5345	5075	state.addr = 58555672873677120LLU; // CPBALANCE_
5346	5076	break;
5347	5077	}
5348		- case 18446744073709551428LLU: // 999999997D'''''''''''''''
	5078	+ case 18446744073709551436LLU: // 999999997L'''''''''''''''
5349	5079	{
5350	5080
5351	5081	access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /mutable1__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 7LLU));

		@@ -5420,7 +5150,7 @@
5420	5150	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5421	5151	}
5422	5152	// ACCUMULATE ARGUMENTS - END
5423		- uint64_t return_to = 18446744073709551425LLU;
	5153	+ uint64_t return_to = 18446744073709551433LLU;
5424	5154	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5425	5155	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5426	5156	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5429,7 +5159,7 @@
5429	5159	state.addr = 367395560426147840LLU; // TYPECOPY__
5430	5160	break;
5431	5161	}
5432		- case 18446744073709551425LLU: // 999999997A'''''''''''''''
	5162	+ case 18446744073709551433LLU: // 999999997I'''''''''''''''
5433	5163	{
5434	5164	{
5435	5165	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -5458,7 +5188,7 @@
5458	5188	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5459	5189	}
5460	5190	// ACCUMULATE ARGUMENTS - END
5461		- uint64_t return_to = 18446744073709551424LLU;
	5191	+ uint64_t return_to = 18446744073709551432LLU;
5462	5192	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5463	5193	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5464	5194	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5467,7 +5197,7 @@
5467	5197	state.addr = 552446646280519680LLU; // copyu64___
5468	5198	break;
5469	5199	}
5470		- case 18446744073709551424LLU: // 999999997_'''''''''''''''
	5200	+ case 18446744073709551432LLU: // 999999997H'''''''''''''''
5471	5201	{
5472	5202	{
5473	5203	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -5496,7 +5226,7 @@
5496	5226	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5497	5227	}
5498	5228	// ACCUMULATE ARGUMENTS - END
5499		- uint64_t return_to = 18446744073709551423LLU;
	5229	+ uint64_t return_to = 18446744073709551431LLU;
5500	5230	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5501	5231	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5502	5232	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5505,7 +5235,7 @@
5505	5235	state.addr = 58555672873677120LLU; // CPBALANCE_
5506	5236	break;
5507	5237	}
5508		- case 18446744073709551423LLU: // 9999999969'''''''''''''''
	5238	+ case 18446744073709551431LLU: // 999999997G'''''''''''''''
5509	5239	{
5510	5240	{
5511	5241	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -5534,7 +5264,7 @@
5534	5264	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5535	5265	}
5536	5266	// ACCUMULATE ARGUMENTS - END
5537		- uint64_t return_to = 18446744073709551422LLU;
	5267	+ uint64_t return_to = 18446744073709551430LLU;
5538	5268	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5539	5269	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5540	5270	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5543,7 +5273,7 @@
5543	5273	state.addr = 552446646280519680LLU; // copyu64___
5544	5274	break;
5545	5275	}
5546		- case 18446744073709551422LLU: // 9999999968'''''''''''''''
	5276	+ case 18446744073709551430LLU: // 999999997F'''''''''''''''
5547	5277	{
5548	5278	{
5549	5279	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -5555,7 +5285,7 @@
5555	5285	}
5556	5286	}
5557	5287	// ACCUMULATE ARGUMENTS - END
5558		- uint64_t return_to = 18446744073709551426LLU;
	5288	+ uint64_t return_to = 18446744073709551434LLU;
5559	5289	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
5560	5290	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5561	5291	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5564,7 +5294,7 @@
5564	5294	state.addr = 782700512565788672LLU; // pardef____
5565	5295	break;
5566	5296	}
5567		- case 18446744073709551426LLU: // 999999997B'''''''''''''''
	5297	+ case 18446744073709551434LLU: // 999999997J'''''''''''''''
5568	5298	{
5569	5299	// parameter-reference u64 reference1 goes out of scope
5570	5300	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference1 at 6

		@@ -5599,10 +5329,10 @@
5599	5329	uint64_t arg = 0;
5600	5330	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
5601	5331	}
5602		- state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
	5332	+ state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5603	5333	break;
5604	5334	}
5605		- case 18446744073709551421LLU: // 9999999967'''''''''''''''
	5335	+ case 18446744073709551429LLU: // 999999997E'''''''''''''''
5606	5336	{
5607	5337	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5608	5338	{

		@@ -5609,7 +5339,7 @@
5609	5339	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5610	5340	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5611	5341	{
5612		- state.addr = 18446744073709551420LLU; // 9999999966'''''''''''''''
	5342	+ state.addr = 18446744073709551428LLU; // 999999997D'''''''''''''''
5613	5343	break;
5614	5344	}
5615	5345	}

		@@ -5629,7 +5359,7 @@
5629	5359	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5630	5360	}
5631	5361	// ACCUMULATE ARGUMENTS - END
5632		- uint64_t return_to = 18446744073709551416LLU;
	5362	+ uint64_t return_to = 18446744073709551424LLU;
5633	5363	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5634	5364	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5635	5365	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5638,12 +5368,12 @@
5638	5368	state.addr = 296309897384864500LLU; // ParDefCopy
5639	5369	break;
5640	5370	}
5641		- case 18446744073709551416LLU: // 9999999962'''''''''''''''
	5371	+ case 18446744073709551424LLU: // 999999997_'''''''''''''''
5642	5372	{
5643		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551419LLU : 18446744073709551418LLU;
	5373	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551427LLU : 18446744073709551426LLU;
5644	5374	break;
5645	5375	}
5646		- case 18446744073709551419LLU: // 9999999965'''''''''''''''
	5376	+ case 18446744073709551427LLU: // 999999997C'''''''''''''''
5647	5377	{
5648	5378	{
5649	5379	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size");

		@@ -5656,35 +5386,35 @@
5656	5386	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5657	5387	}
5658	5388	// ACCUMULATE ARGUMENTS - END
5659		- uint64_t return_to = 18446744073709551415LLU;
	5389	+ uint64_t return_to = 18446744073709551423LLU;
5660	5390	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5661	5391	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5662	5392	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5663	5393	heap.data[0].elem1 = heap.data[0].elem0;
5664	5394	heap.data[0].elem0 = restore;
5665		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	5395	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
5666	5396	break;
5667	5397	}
5668		- case 18446744073709551415LLU: // 9999999961'''''''''''''''
	5398	+ case 18446744073709551423LLU: // 9999999969'''''''''''''''
5669	5399	{
5670	5400	// parameter pardef____ dst_______ goes out of scope
5671		- state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
	5401	+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
5672	5402	break;
5673	5403	}
5674		- case 18446744073709551418LLU: // 9999999964'''''''''''''''
	5404	+ case 18446744073709551426LLU: // 999999997B'''''''''''''''
5675	5405	{
5676		- state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
	5406	+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
5677	5407	break;
5678	5408	}
5679		- case 18446744073709551417LLU: // 9999999963'''''''''''''''
	5409	+ case 18446744073709551425LLU: // 999999997A'''''''''''''''
5680	5410	{
5681	5411	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
5682	5412	// parameter-reference pardef____ src_______ goes out of scope
5683	5413	// parameter-reference list<pardef____> srcs______ goes out of scope
5684		- state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
	5414	+ state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5685	5415	break;
5686	5416	}
5687		- case 18446744073709551420LLU: // 9999999966'''''''''''''''
	5417	+ case 18446744073709551428LLU: // 999999997D'''''''''''''''
5688	5418	{
5689	5419	swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
5690	5420	// variable list<pardef____> dsts______ goes out of scope

		@@ -5715,10 +5445,10 @@
5715	5445	uint64_t arg = 0;
5716	5446	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
5717	5447	}
5718		- state.addr = 18446744073709551414LLU; // 9999999960'''''''''''''''
	5448	+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
5719	5449	break;
5720	5450	}
5721		- case 18446744073709551414LLU: // 9999999960'''''''''''''''
	5451	+ case 18446744073709551422LLU: // 9999999968'''''''''''''''
5722	5452	{
5723	5453	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
5724	5454	{

		@@ -5725,7 +5455,7 @@
5725	5455	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
5726	5456	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5727	5457	{
5728		- state.addr = 18446744073709551413LLU; // 999999996z'''''''''''''''
	5458	+ state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
5729	5459	break;
5730	5460	}
5731	5461	}

		@@ -5755,7 +5485,7 @@
5755	5485	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5756	5486	}
5757	5487	// ACCUMULATE ARGUMENTS - END
5758		- uint64_t return_to = 18446744073709551412LLU;
	5488	+ uint64_t return_to = 18446744073709551420LLU;
5759	5489	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5760	5490	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5761	5491	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5764,7 +5494,7 @@
5764	5494	state.addr = 367395560426147840LLU; // TYPECOPY__
5765	5495	break;
5766	5496	}
5767		- case 18446744073709551412LLU: // 999999996y'''''''''''''''
	5497	+ case 18446744073709551420LLU: // 9999999966'''''''''''''''
5768	5498	{
5769	5499	{
5770	5500	uint64_t arg = 0;

		@@ -5776,7 +5506,7 @@
5776	5506	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5777	5507	}
5778	5508	// ACCUMULATE ARGUMENTS - END
5779		- uint64_t return_to = 18446744073709551411LLU;
	5509	+ uint64_t return_to = 18446744073709551419LLU;
5780	5510	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5781	5511	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5782	5512	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5785,7 +5515,7 @@
5785	5515	state.addr = 552437437528276992LLU; // consume___
5786	5516	break;
5787	5517	}
5788		- case 18446744073709551411LLU: // 999999996x'''''''''''''''
	5518	+ case 18446744073709551419LLU: // 9999999965'''''''''''''''
5789	5519	{
5790	5520	{
5791	5521	uint64_t arg = 0;

		@@ -5813,7 +5543,7 @@
5813	5543	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5814	5544	}
5815	5545	// ACCUMULATE ARGUMENTS - END
5816		- uint64_t return_to = 18446744073709551407LLU;
	5546	+ uint64_t return_to = 18446744073709551415LLU;
5817	5547	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
5818	5548	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5819	5549	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5822,12 +5552,12 @@
5822	5552	state.addr = 782700512565788672LLU; // pardef____
5823	5553	break;
5824	5554	}
5825		- case 18446744073709551407LLU: // 999999996t'''''''''''''''
	5555	+ case 18446744073709551415LLU: // 9999999961'''''''''''''''
5826	5556	{
5827		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551410LLU : 18446744073709551409LLU;
	5557	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551418LLU : 18446744073709551417LLU;
5828	5558	break;
5829	5559	}
5830		- case 18446744073709551410LLU: // 999999996w'''''''''''''''
	5560	+ case 18446744073709551418LLU: // 9999999964'''''''''''''''
5831	5561	{
5832	5562	fprintf(stderr, "%s", "pushing par ");
5833	5563	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -5836,7 +5566,7 @@
5836	5566	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5837	5567	}
5838	5568	// ACCUMULATE ARGUMENTS - END
5839		- uint64_t return_to = 18446744073709551406LLU;
	5569	+ uint64_t return_to = 18446744073709551414LLU;
5840	5570	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5841	5571	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5842	5572	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5845,7 +5575,7 @@
5845	5575	state.addr = 819847183518878432LLU; // reporttype
5846	5576	break;
5847	5577	}
5848		- case 18446744073709551406LLU: // 999999996s'''''''''''''''
	5578	+ case 18446744073709551414LLU: // 9999999960'''''''''''''''
5849	5579	{
5850	5580	fprintf(stderr, "%s", "\n");
5851	5581	{

		@@ -5859,27 +5589,27 @@
5859	5589	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5860	5590	}
5861	5591	// ACCUMULATE ARGUMENTS - END
5862		- uint64_t return_to = 18446744073709551405LLU;
	5592	+ uint64_t return_to = 18446744073709551413LLU;
5863	5593	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
5864	5594	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5865	5595	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5866	5596	heap.data[0].elem1 = heap.data[0].elem0;
5867	5597	heap.data[0].elem0 = restore;
5868		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	5598	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
5869	5599	break;
5870	5600	}
5871		- case 18446744073709551405LLU: // 999999996r'''''''''''''''
	5601	+ case 18446744073709551413LLU: // 999999996z'''''''''''''''
5872	5602	{
5873	5603	// parameter pardef____ newpar____ goes out of scope
5874		- state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
	5604	+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
5875	5605	break;
5876	5606	}
5877		- case 18446744073709551409LLU: // 999999996v'''''''''''''''
	5607	+ case 18446744073709551417LLU: // 9999999963'''''''''''''''
5878	5608	{
5879		- state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
	5609	+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
5880	5610	break;
5881	5611	}
5882		- case 18446744073709551408LLU: // 999999996u'''''''''''''''
	5612	+ case 18446744073709551416LLU: // 9999999962'''''''''''''''
5883	5613	{
5884	5614	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
5885	5615	// variable continuity continuity goes out of scope

		@@ -5896,10 +5626,10 @@
5896	5626	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 7
5897	5627	// parameter-reference elemdef___ src_______ goes out of scope
5898	5628	// parameter-reference list<elemdef___> srcs______ goes out of scope
5899		- state.addr = 18446744073709551414LLU; // 9999999960'''''''''''''''
	5629	+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
5900	5630	break;
5901	5631	}
5902		- case 18446744073709551413LLU: // 999999996z'''''''''''''''
	5632	+ case 18446744073709551421LLU: // 9999999967'''''''''''''''
5903	5633	{
5904	5634	swap(&LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
5905	5635	// variable list<pardef____> dsts______ goes out of scope

		@@ -5951,7 +5681,7 @@
5951	5681	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5952	5682	}
5953	5683	// ACCUMULATE ARGUMENTS - END
5954		- uint64_t return_to = 18446744073709551402LLU;
	5684	+ uint64_t return_to = 18446744073709551410LLU;
5955	5685	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5956	5686	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5957	5687	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5960,7 +5690,7 @@
5960	5690	state.addr = 552446646280519680LLU; // copyu64___
5961	5691	break;
5962	5692	}
5963		- case 18446744073709551402LLU: // 999999996o'''''''''''''''
	5693	+ case 18446744073709551410LLU: // 999999996w'''''''''''''''
5964	5694	{
5965	5695	{
5966	5696	uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 6*/;

		@@ -5989,7 +5719,7 @@
5989	5719	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5990	5720	}
5991	5721	// ACCUMULATE ARGUMENTS - END
5992		- uint64_t return_to = 18446744073709551401LLU;
	5722	+ uint64_t return_to = 18446744073709551409LLU;
5993	5723	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
5994	5724	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5995	5725	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -5998,7 +5728,7 @@
5998	5728	state.addr = 367395560426147840LLU; // TYPECOPY__
5999	5729	break;
6000	5730	}
6001		- case 18446744073709551401LLU: // 999999996n'''''''''''''''
	5731	+ case 18446744073709551409LLU: // 999999996v'''''''''''''''
6002	5732	{
6003	5733	{
6004	5734	uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 6*/;

		@@ -6010,7 +5740,7 @@
6010	5740	}
6011	5741	}
6012	5742	// ACCUMULATE ARGUMENTS - END
6013		- uint64_t return_to = 18446744073709551403LLU;
	5743	+ uint64_t return_to = 18446744073709551411LLU;
6014	5744	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
6015	5745	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6016	5746	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6019,7 +5749,7 @@
6019	5749	state.addr = 587581796494082048LLU; // elemdef___
6020	5750	break;
6021	5751	}
6022		- case 18446744073709551403LLU: // 999999996p'''''''''''''''
	5752	+ case 18446744073709551411LLU: // 999999996x'''''''''''''''
6023	5753	{
6024	5754	// parameter-reference type______ type1_____ goes out of scope
6025	5755	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type1_____ at 4

		@@ -6050,10 +5780,10 @@
6050	5780	uint64_t arg = 0;
6051	5781	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
6052	5782	}
6053		- state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
	5783	+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
6054	5784	break;
6055	5785	}
6056		- case 18446744073709551400LLU: // 999999996m'''''''''''''''
	5786	+ case 18446744073709551408LLU: // 999999996u'''''''''''''''
6057	5787	{
6058	5788	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6059	5789	{

		@@ -6060,7 +5790,7 @@
6060	5790	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
6061	5791	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6062	5792	{
6063		- state.addr = 18446744073709551399LLU; // 999999996l'''''''''''''''
	5793	+ state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
6064	5794	break;
6065	5795	}
6066	5796	}

		@@ -6080,7 +5810,7 @@
6080	5810	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6081	5811	}
6082	5812	// ACCUMULATE ARGUMENTS - END
6083		- uint64_t return_to = 18446744073709551395LLU;
	5813	+ uint64_t return_to = 18446744073709551403LLU;
6084	5814	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6085	5815	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6086	5816	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6089,12 +5819,12 @@
6089	5819	state.addr = 101193007747052544LLU; // ElemDefCP_
6090	5820	break;
6091	5821	}
6092		- case 18446744073709551395LLU: // 999999996h'''''''''''''''
	5822	+ case 18446744073709551403LLU: // 999999996p'''''''''''''''
6093	5823	{
6094		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551398LLU : 18446744073709551397LLU;
	5824	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551406LLU : 18446744073709551405LLU;
6095	5825	break;
6096	5826	}
6097		- case 18446744073709551398LLU: // 999999996k'''''''''''''''
	5827	+ case 18446744073709551406LLU: // 999999996s'''''''''''''''
6098	5828	{
6099	5829	fprintf(stderr, "%s", "pushing par ");
6100	5830	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -6103,7 +5833,7 @@
6103	5833	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6104	5834	}
6105	5835	// ACCUMULATE ARGUMENTS - END
6106		- uint64_t return_to = 18446744073709551394LLU;
	5836	+ uint64_t return_to = 18446744073709551402LLU;
6107	5837	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6108	5838	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6109	5839	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6112,7 +5842,7 @@
6112	5842	state.addr = 819847183518878432LLU; // reporttype
6113	5843	break;
6114	5844	}
6115		- case 18446744073709551394LLU: // 999999996g'''''''''''''''
	5845	+ case 18446744073709551402LLU: // 999999996o'''''''''''''''
6116	5846	{
6117	5847	fprintf(stderr, "%s", "\n");
6118	5848	{

		@@ -6126,35 +5856,35 @@
6126	5856	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6127	5857	}
6128	5858	// ACCUMULATE ARGUMENTS - END
6129		- uint64_t return_to = 18446744073709551393LLU;
	5859	+ uint64_t return_to = 18446744073709551401LLU;
6130	5860	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6131	5861	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6132	5862	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6133	5863	heap.data[0].elem1 = heap.data[0].elem0;
6134	5864	heap.data[0].elem0 = restore;
6135		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	5865	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
6136	5866	break;
6137	5867	}
6138		- case 18446744073709551393LLU: // 999999996f'''''''''''''''
	5868	+ case 18446744073709551401LLU: // 999999996n'''''''''''''''
6139	5869	{
6140	5870	// parameter elemdef___ dst_______ goes out of scope
6141		- state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	5871	+ state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
6142	5872	break;
6143	5873	}
6144		- case 18446744073709551397LLU: // 999999996j'''''''''''''''
	5874	+ case 18446744073709551405LLU: // 999999996r'''''''''''''''
6145	5875	{
6146		- state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	5876	+ state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
6147	5877	break;
6148	5878	}
6149		- case 18446744073709551396LLU: // 999999996i'''''''''''''''
	5879	+ case 18446744073709551404LLU: // 999999996q'''''''''''''''
6150	5880	{
6151	5881	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
6152	5882	// parameter-reference elemdef___ src_______ goes out of scope
6153	5883	// parameter-reference list<elemdef___> srcs______ goes out of scope
6154		- state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
	5884	+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
6155	5885	break;
6156	5886	}
6157		- case 18446744073709551399LLU: // 999999996l'''''''''''''''
	5887	+ case 18446744073709551407LLU: // 999999996t'''''''''''''''
6158	5888	{
6159	5889	swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
6160	5890	// variable list<elemdef___> dsts______ goes out of scope

		@@ -6208,7 +5938,7 @@
6208	5938	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6209	5939	}
6210	5940	// ACCUMULATE ARGUMENTS - END
6211		- uint64_t return_to = 18446744073709551390LLU;
	5941	+ uint64_t return_to = 18446744073709551398LLU;
6212	5942	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6213	5943	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6214	5944	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6217,7 +5947,7 @@
6217	5947	state.addr = 367395560426147840LLU; // TYPECOPY__
6218	5948	break;
6219	5949	}
6220		- case 18446744073709551390LLU: // 999999996c'''''''''''''''
	5950	+ case 18446744073709551398LLU: // 999999996k'''''''''''''''
6221	5951	{
6222	5952	{
6223	5953	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -6246,7 +5976,7 @@
6246	5976	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6247	5977	}
6248	5978	// ACCUMULATE ARGUMENTS - END
6249		- uint64_t return_to = 18446744073709551389LLU;
	5979	+ uint64_t return_to = 18446744073709551397LLU;
6250	5980	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6251	5981	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6252	5982	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6255,7 +5985,7 @@
6255	5985	state.addr = 552446646280519680LLU; // copyu64___
6256	5986	break;
6257	5987	}
6258		- case 18446744073709551389LLU: // 999999996b'''''''''''''''
	5988	+ case 18446744073709551397LLU: // 999999996j'''''''''''''''
6259	5989	{
6260	5990	{
6261	5991	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -6284,7 +6014,7 @@
6284	6014	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6285	6015	}
6286	6016	// ACCUMULATE ARGUMENTS - END
6287		- uint64_t return_to = 18446744073709551388LLU;
	6017	+ uint64_t return_to = 18446744073709551396LLU;
6288	6018	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6289	6019	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6290	6020	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6293,7 +6023,7 @@
6293	6023	state.addr = 552446646280519680LLU; // copyu64___
6294	6024	break;
6295	6025	}
6296		- case 18446744073709551388LLU: // 999999996a'''''''''''''''
	6026	+ case 18446744073709551396LLU: // 999999996i'''''''''''''''
6297	6027	{
6298	6028	{
6299	6029	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -6305,7 +6035,7 @@
6305	6035	}
6306	6036	}
6307	6037	// ACCUMULATE ARGUMENTS - END
6308		- uint64_t return_to = 18446744073709551391LLU;
	6038	+ uint64_t return_to = 18446744073709551399LLU;
6309	6039	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
6310	6040	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6311	6041	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6314,7 +6044,7 @@
6314	6044	state.addr = 819859607768530944LLU; // resdest___
6315	6045	break;
6316	6046	}
6317		- case 18446744073709551391LLU: // 999999996d'''''''''''''''
	6047	+ case 18446744073709551399LLU: // 999999996l'''''''''''''''
6318	6048	{
6319	6049	// parameter-reference u64 reference1 goes out of scope
6320	6050	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference1 at 5

		@@ -6333,7 +6063,7 @@
6333	6063	}
6334	6064	break;
6335	6065	}
6336		- case 18446744073709551387LLU: // 999999996$'''''''''''''''
	6066	+ case 18446744073709551395LLU: // 999999996h'''''''''''''''
6337	6067	{
6338	6068	{
6339	6069	uint64_t arg = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -6390,7 +6120,7 @@
6390	6120	}
6391	6121	break;
6392	6122	}
6393		- case 18446744073709551386LLU: // 999999996Z'''''''''''''''
	6123	+ case 18446744073709551394LLU: // 999999996g'''''''''''''''
6394	6124	{
6395	6125	{
6396	6126	uint64_t arg = tree_pop_move(&heap, 7LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -6432,14 +6162,14 @@
6432	6162	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
6433	6163	}
6434	6164	// emitted destructur for type list<pardef____>
6435		- state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
	6165	+ state.addr = 18446744073709551392LLU; // 999999996e'''''''''''''''
6436	6166	break;
6437	6167	}
6438		- case 18446744073709551384LLU: // 999999996X'''''''''''''''
	6168	+ case 18446744073709551392LLU: // 999999996e'''''''''''''''
6439	6169	{
6440	6170	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
6441	6171	{
6442		- state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
	6172	+ state.addr = 18446744073709551393LLU; // 999999996f'''''''''''''''
6443	6173	break;
6444	6174	}
6445	6175	// temporary list-element

		@@ -6453,23 +6183,23 @@
6453	6183	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6454	6184	}
6455	6185	// ACCUMULATE ARGUMENTS - END
6456		- uint64_t return_to = 18446744073709551383LLU;
	6186	+ uint64_t return_to = 18446744073709551391LLU;
6457	6187	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6458	6188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6459	6189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6460	6190	heap.data[0].elem1 = heap.data[0].elem0;
6461	6191	heap.data[0].elem0 = restore;
6462		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	6192	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
6463	6193	break;
6464	6194	}
6465		- case 18446744073709551383LLU: // 999999996W'''''''''''''''
	6195	+ case 18446744073709551391LLU: // 999999996d'''''''''''''''
6466	6196	{
6467	6197	// RELEASE temporary destructor-variable
6468	6198	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
6469		- state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
	6199	+ state.addr = 18446744073709551392LLU; // 999999996e'''''''''''''''
6470	6200	break;
6471	6201	}
6472		- case 18446744073709551385LLU: // 999999996Y'''''''''''''''
	6202	+ case 18446744073709551393LLU: // 999999996f'''''''''''''''
6473	6203	{
6474	6204	// RELEASE temporary destructor-variable
6475	6205	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -6478,14 +6208,14 @@
6478	6208	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
6479	6209	}
6480	6210	// emitted destructur for type list<resdest___>
6481		- state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
	6211	+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
6482	6212	break;
6483	6213	}
6484		- case 18446744073709551381LLU: // 999999996U'''''''''''''''
	6214	+ case 18446744073709551389LLU: // 999999996b'''''''''''''''
6485	6215	{
6486	6216	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
6487	6217	{
6488		- state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
	6218	+ state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
6489	6219	break;
6490	6220	}
6491	6221	// temporary list-element

		@@ -6499,7 +6229,7 @@
6499	6229	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6500	6230	}
6501	6231	// ACCUMULATE ARGUMENTS - END
6502		- uint64_t return_to = 18446744073709551380LLU;
	6232	+ uint64_t return_to = 18446744073709551388LLU;
6503	6233	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6504	6234	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6505	6235	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6508,14 +6238,14 @@
6508	6238	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6509	6239	break;
6510	6240	}
6511		- case 18446744073709551380LLU: // 999999996T'''''''''''''''
	6241	+ case 18446744073709551388LLU: // 999999996a'''''''''''''''
6512	6242	{
6513	6243	// RELEASE temporary destructor-variable
6514	6244	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
6515		- state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
	6245	+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
6516	6246	break;
6517	6247	}
6518		- case 18446744073709551382LLU: // 999999996V'''''''''''''''
	6248	+ case 18446744073709551390LLU: // 999999996c'''''''''''''''
6519	6249	{
6520	6250	// RELEASE temporary destructor-variable
6521	6251	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -6637,10 +6367,10 @@
6637	6367	uint64_t arg = 0;
6638	6368	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
6639	6369	}
6640		- state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
	6370	+ state.addr = 18446744073709551386LLU; // 999999996Z'''''''''''''''
6641	6371	break;
6642	6372	}
6643		- case 18446744073709551378LLU: // 999999996R'''''''''''''''
	6373	+ case 18446744073709551386LLU: // 999999996Z'''''''''''''''
6644	6374	{
6645	6375	if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
6646	6376	{

		@@ -6647,7 +6377,7 @@
6647	6377	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
6648	6378	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
6649	6379	{
6650		- state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
	6380	+ state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
6651	6381	break;
6652	6382	}
6653	6383	}

		@@ -6667,7 +6397,7 @@
6667	6397	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6668	6398	}
6669	6399	// ACCUMULATE ARGUMENTS - END
6670		- uint64_t return_to = 18446744073709551373LLU;
	6400	+ uint64_t return_to = 18446744073709551381LLU;
6671	6401	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6672	6402	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6673	6403	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6676,12 +6406,12 @@
6676	6406	state.addr = 333468934555566080LLU; // ResCopy___
6677	6407	break;
6678	6408	}
6679		- case 18446744073709551373LLU: // 999999996M'''''''''''''''
	6409	+ case 18446744073709551381LLU: // 999999996U'''''''''''''''
6680	6410	{
6681		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551376LLU : 18446744073709551375LLU;
	6411	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551384LLU : 18446744073709551383LLU;
6682	6412	break;
6683	6413	}
6684		- case 18446744073709551376LLU: // 999999996P'''''''''''''''
	6414	+ case 18446744073709551384LLU: // 999999996X'''''''''''''''
6685	6415	{
6686	6416	{
6687	6417	fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");

		@@ -6694,7 +6424,7 @@
6694	6424	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6695	6425	}
6696	6426	// ACCUMULATE ARGUMENTS - END
6697		- uint64_t return_to = 18446744073709551372LLU;
	6427	+ uint64_t return_to = 18446744073709551380LLU;
6698	6428	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6699	6429	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6700	6430	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6703,26 +6433,26 @@
6703	6433	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6704	6434	break;
6705	6435	}
6706		- case 18446744073709551372LLU: // 999999996L'''''''''''''''
	6436	+ case 18446744073709551380LLU: // 999999996T'''''''''''''''
6707	6437	{
6708	6438	// parameter resdest___ RP________ goes out of scope
6709		- state.addr = 18446744073709551374LLU; // 999999996N'''''''''''''''
	6439	+ state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
6710	6440	break;
6711	6441	}
6712		- case 18446744073709551375LLU: // 999999996O'''''''''''''''
	6442	+ case 18446744073709551383LLU: // 999999996W'''''''''''''''
6713	6443	{
6714		- state.addr = 18446744073709551374LLU; // 999999996N'''''''''''''''
	6444	+ state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
6715	6445	break;
6716	6446	}
6717		- case 18446744073709551374LLU: // 999999996N'''''''''''''''
	6447	+ case 18446744073709551382LLU: // 999999996V'''''''''''''''
6718	6448	{
6719	6449	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
6720	6450	// parameter-reference resdest___ rp________ goes out of scope
6721	6451	// parameter-reference list<resdest___> resultpars goes out of scope
6722		- state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
	6452	+ state.addr = 18446744073709551386LLU; // 999999996Z'''''''''''''''
6723	6453	break;
6724	6454	}
6725		- case 18446744073709551377LLU: // 999999996Q'''''''''''''''
	6455	+ case 18446744073709551385LLU: // 999999996Y'''''''''''''''
6726	6456	{
6727	6457	list_reverse(heap.data, &/RESULTPARS/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
6728	6458	{

		@@ -6737,10 +6467,10 @@
6737	6467	uint64_t arg = 0;
6738	6468	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
6739	6469	}
6740		- state.addr = 18446744073709551371LLU; // 999999996K'''''''''''''''
	6470	+ state.addr = 18446744073709551379LLU; // 999999996S'''''''''''''''
6741	6471	break;
6742	6472	}
6743		- case 18446744073709551371LLU: // 999999996K'''''''''''''''
	6473	+ case 18446744073709551379LLU: // 999999996S'''''''''''''''
6744	6474	{
6745	6475	if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU))
6746	6476	{

		@@ -6747,7 +6477,7 @@
6747	6477	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
6748	6478	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
6749	6479	{
6750		- state.addr = 18446744073709551370LLU; // 999999996J'''''''''''''''
	6480	+ state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
6751	6481	break;
6752	6482	}
6753	6483	}

		@@ -6767,7 +6497,7 @@
6767	6497	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6768	6498	}
6769	6499	// ACCUMULATE ARGUMENTS - END
6770		- uint64_t return_to = 18446744073709551366LLU;
	6500	+ uint64_t return_to = 18446744073709551374LLU;
6771	6501	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6772	6502	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6773	6503	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6776,12 +6506,12 @@
6776	6506	state.addr = 296309897384864500LLU; // ParDefCopy
6777	6507	break;
6778	6508	}
6779		- case 18446744073709551366LLU: // 999999996F'''''''''''''''
	6509	+ case 18446744073709551374LLU: // 999999996N'''''''''''''''
6780	6510	{
6781		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551369LLU : 18446744073709551368LLU;
	6511	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551377LLU : 18446744073709551376LLU;
6782	6512	break;
6783	6513	}
6784		- case 18446744073709551369LLU: // 999999996I'''''''''''''''
	6514	+ case 18446744073709551377LLU: // 999999996Q'''''''''''''''
6785	6515	{
6786	6516	{
6787	6517	fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");

		@@ -6794,35 +6524,35 @@
6794	6524	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6795	6525	}
6796	6526	// ACCUMULATE ARGUMENTS - END
6797		- uint64_t return_to = 18446744073709551365LLU;
	6527	+ uint64_t return_to = 18446744073709551373LLU;
6798	6528	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
6799	6529	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6800	6530	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6801	6531	heap.data[0].elem1 = heap.data[0].elem0;
6802	6532	heap.data[0].elem0 = restore;
6803		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	6533	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
6804	6534	break;
6805	6535	}
6806		- case 18446744073709551365LLU: // 999999996E'''''''''''''''
	6536	+ case 18446744073709551373LLU: // 999999996M'''''''''''''''
6807	6537	{
6808	6538	// parameter pardef____ DP________ goes out of scope
6809		- state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
	6539	+ state.addr = 18446744073709551375LLU; // 999999996O'''''''''''''''
6810	6540	break;
6811	6541	}
6812		- case 18446744073709551368LLU: // 999999996H'''''''''''''''
	6542	+ case 18446744073709551376LLU: // 999999996P'''''''''''''''
6813	6543	{
6814		- state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
	6544	+ state.addr = 18446744073709551375LLU; // 999999996O'''''''''''''''
6815	6545	break;
6816	6546	}
6817		- case 18446744073709551367LLU: // 999999996G'''''''''''''''
	6547	+ case 18446744073709551375LLU: // 999999996O'''''''''''''''
6818	6548	{
6819	6549	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 14
6820	6550	// parameter-reference pardef____ dp________ goes out of scope
6821	6551	// parameter-reference list<pardef____> defpars___ goes out of scope
6822		- state.addr = 18446744073709551371LLU; // 999999996K'''''''''''''''
	6552	+ state.addr = 18446744073709551379LLU; // 999999996S'''''''''''''''
6823	6553	break;
6824	6554	}
6825		- case 18446744073709551370LLU: // 999999996J'''''''''''''''
	6555	+ case 18446744073709551378LLU: // 999999996R'''''''''''''''
6826	6556	{
6827	6557	list_reverse(heap.data, &/DEFPARS___/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU));
6828	6558	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -6856,7 +6586,7 @@
6856	6586	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6857	6587	}
6858	6588	// ACCUMULATE ARGUMENTS - END
6859		- uint64_t return_to = 18446744073709551363LLU;
	6589	+ uint64_t return_to = 18446744073709551371LLU;
6860	6590	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6861	6591	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6862	6592	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6865,7 +6595,7 @@
6865	6595	state.addr = 552446646280519680LLU; // copyu64___
6866	6596	break;
6867	6597	}
6868		- case 18446744073709551363LLU: // 999999996C'''''''''''''''
	6598	+ case 18446744073709551371LLU: // 999999996K'''''''''''''''
6869	6599	{
6870	6600	{
6871	6601	uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 13*/;

		@@ -6894,7 +6624,7 @@
6894	6624	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6895	6625	}
6896	6626	// ACCUMULATE ARGUMENTS - END
6897		- uint64_t return_to = 18446744073709551362LLU;
	6627	+ uint64_t return_to = 18446744073709551370LLU;
6898	6628	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6899	6629	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6900	6630	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6903,7 +6633,7 @@
6903	6633	state.addr = 552446646280519680LLU; // copyu64___
6904	6634	break;
6905	6635	}
6906		- case 18446744073709551362LLU: // 999999996B'''''''''''''''
	6636	+ case 18446744073709551370LLU: // 999999996J'''''''''''''''
6907	6637	{
6908	6638	{
6909	6639	uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 13*/;

		@@ -6932,7 +6662,7 @@
6932	6662	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6933	6663	}
6934	6664	// ACCUMULATE ARGUMENTS - END
6935		- uint64_t return_to = 18446744073709551361LLU;
	6665	+ uint64_t return_to = 18446744073709551369LLU;
6936	6666	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6937	6667	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6938	6668	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6941,7 +6671,7 @@
6941	6671	state.addr = 552446646280519680LLU; // copyu64___
6942	6672	break;
6943	6673	}
6944		- case 18446744073709551361LLU: // 999999996A'''''''''''''''
	6674	+ case 18446744073709551369LLU: // 999999996I'''''''''''''''
6945	6675	{
6946	6676	{
6947	6677	uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 13*/;

		@@ -6970,7 +6700,7 @@
6970	6700	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6971	6701	}
6972	6702	// ACCUMULATE ARGUMENTS - END
6973		- uint64_t return_to = 18446744073709551360LLU;
	6703	+ uint64_t return_to = 18446744073709551368LLU;
6974	6704	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
6975	6705	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6976	6706	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -6979,7 +6709,7 @@
6979	6709	state.addr = 552446646280519680LLU; // copyu64___
6980	6710	break;
6981	6711	}
6982		- case 18446744073709551360LLU: // 999999996_'''''''''''''''
	6712	+ case 18446744073709551368LLU: // 999999996H'''''''''''''''
6983	6713	{
6984	6714	{
6985	6715	uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 13*/;

		@@ -7008,7 +6738,7 @@
7008	6738	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7009	6739	}
7010	6740	// ACCUMULATE ARGUMENTS - END
7011		- uint64_t return_to = 18446744073709551359LLU;
	6741	+ uint64_t return_to = 18446744073709551367LLU;
7012	6742	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
7013	6743	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7014	6744	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7017,7 +6747,7 @@
7017	6747	state.addr = 552446646280519680LLU; // copyu64___
7018	6748	break;
7019	6749	}
7020		- case 18446744073709551359LLU: // 9999999959'''''''''''''''
	6750	+ case 18446744073709551367LLU: // 999999996G'''''''''''''''
7021	6751	{
7022	6752	{
7023	6753	uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 13*/;

		@@ -7029,7 +6759,7 @@
7029	6759	}
7030	6760	}
7031	6761	// ACCUMULATE ARGUMENTS - END
7032		- uint64_t return_to = 18446744073709551364LLU;
	6762	+ uint64_t return_to = 18446744073709551372LLU;
7033	6763	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0));
7034	6764	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7035	6765	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7038,7 +6768,7 @@
7038	6768	state.addr = 608168382267297792LLU; // function__
7039	6769	break;
7040	6770	}
7041		- case 18446744073709551364LLU: // 999999996D'''''''''''''''
	6771	+ case 18446744073709551372LLU: // 999999996L'''''''''''''''
7042	6772	{
7043	6773	// variable list<pardef____> DEFPARS___ goes out of scope
7044	6774	// (uninitialized -> no destructor-call)

		@@ -7153,10 +6883,10 @@
7153	6883	uint64_t arg = 0;
7154	6884	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
7155	6885	}
7156		- state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
	6886	+ state.addr = 18446744073709551366LLU; // 999999996F'''''''''''''''
7157	6887	break;
7158	6888	}
7159		- case 18446744073709551358LLU: // 9999999958'''''''''''''''
	6889	+ case 18446744073709551366LLU: // 999999996F'''''''''''''''
7160	6890	{
7161	6891	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7162	6892	{

		@@ -7163,7 +6893,7 @@
7163	6893	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
7164	6894	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7165	6895	{
7166		- state.addr = 18446744073709551357LLU; // 9999999957'''''''''''''''
	6896	+ state.addr = 18446744073709551365LLU; // 999999996E'''''''''''''''
7167	6897	break;
7168	6898	}
7169	6899	}

		@@ -7183,7 +6913,7 @@
7183	6913	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7184	6914	}
7185	6915	// ACCUMULATE ARGUMENTS - END
7186		- uint64_t return_to = 18446744073709551353LLU;
	6916	+ uint64_t return_to = 18446744073709551361LLU;
7187	6917	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
7188	6918	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7189	6919	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7192,12 +6922,12 @@
7192	6922	state.addr = 325750391286068249LLU; // RESDEFCOPY
7193	6923	break;
7194	6924	}
7195		- case 18446744073709551353LLU: // 9999999953'''''''''''''''
	6925	+ case 18446744073709551361LLU: // 999999996A'''''''''''''''
7196	6926	{
7197		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551356LLU : 18446744073709551355LLU;
	6927	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551364LLU : 18446744073709551363LLU;
7198	6928	break;
7199	6929	}
7200		- case 18446744073709551356LLU: // 9999999956'''''''''''''''
	6930	+ case 18446744073709551364LLU: // 999999996D'''''''''''''''
7201	6931	{
7202	6932	{
7203	6933	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -7210,7 +6940,7 @@
7210	6940	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7211	6941	}
7212	6942	// ACCUMULATE ARGUMENTS - END
7213		- uint64_t return_to = 18446744073709551352LLU;
	6943	+ uint64_t return_to = 18446744073709551360LLU;
7214	6944	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7215	6945	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7216	6946	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7219,26 +6949,26 @@
7219	6949	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7220	6950	break;
7221	6951	}
7222		- case 18446744073709551352LLU: // 9999999952'''''''''''''''
	6952	+ case 18446744073709551360LLU: // 999999996_'''''''''''''''
7223	6953	{
7224	6954	// parameter resdest___ new_______ goes out of scope
7225		- state.addr = 18446744073709551354LLU; // 9999999954'''''''''''''''
	6955	+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
7226	6956	break;
7227	6957	}
7228		- case 18446744073709551355LLU: // 9999999955'''''''''''''''
	6958	+ case 18446744073709551363LLU: // 999999996C'''''''''''''''
7229	6959	{
7230		- state.addr = 18446744073709551354LLU; // 9999999954'''''''''''''''
	6960	+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
7231	6961	break;
7232	6962	}
7233		- case 18446744073709551354LLU: // 9999999954'''''''''''''''
	6963	+ case 18446744073709551362LLU: // 999999996B'''''''''''''''
7234	6964	{
7235	6965	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
7236	6966	// parameter-reference resdest___ respar1___ goes out of scope
7237	6967	// parameter-reference list<resdest___> yresults__ goes out of scope
7238		- state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
	6968	+ state.addr = 18446744073709551366LLU; // 999999996F'''''''''''''''
7239	6969	break;
7240	6970	}
7241		- case 18446744073709551357LLU: // 9999999957'''''''''''''''
	6971	+ case 18446744073709551365LLU: // 999999996E'''''''''''''''
7242	6972	{
7243	6973	list_reverse(heap.data, &/yres______/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
7244	6974	{

		@@ -7249,10 +6979,10 @@
7249	6979	uint64_t arg = 0;
7250	6980	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
7251	6981	}
7252		- state.addr = 18446744073709551351LLU; // 9999999951'''''''''''''''
	6982	+ state.addr = 18446744073709551359LLU; // 9999999959'''''''''''''''
7253	6983	break;
7254	6984	}
7255		- case 18446744073709551351LLU: // 9999999951'''''''''''''''
	6985	+ case 18446744073709551359LLU: // 9999999959'''''''''''''''
7256	6986	{
7257	6987	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7258	6988	{

		@@ -7259,16 +6989,16 @@
7259	6989	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
7260	6990	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7261	6991	{
7262		- state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
	6992	+ state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
7263	6993	break;
7264	6994	}
7265	6995	}
7266	6996	/direct/LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7267	6997	LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7268		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551349LLU : 18446744073709551348LLU;
	6998	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551357LLU : 18446744073709551356LLU;
7269	6999	break;
7270	7000	}
7271		- case 18446744073709551349LLU: // 999999995z'''''''''''''''
	7001	+ case 18446744073709551357LLU: // 9999999957'''''''''''''''
7272	7002	{
7273	7003	{
7274	7004	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/list*/, 8);

		@@ -7293,7 +7023,7 @@
7293	7023	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7294	7024	}
7295	7025	// ACCUMULATE ARGUMENTS - END
7296		- uint64_t return_to = 18446744073709551346LLU;
	7026	+ uint64_t return_to = 18446744073709551354LLU;
7297	7027	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
7298	7028	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7299	7029	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7302,7 +7032,7 @@
7302	7032	state.addr = 589059885019168768LLU; // equres____
7303	7033	break;
7304	7034	}
7305		- case 18446744073709551346LLU: // 999999995w'''''''''''''''
	7035	+ case 18446744073709551354LLU: // 9999999954'''''''''''''''
7306	7036	{
7307	7037
7308	7038	access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU);

		@@ -7317,7 +7047,7 @@
7317	7047	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7318	7048	}
7319	7049	// ACCUMULATE ARGUMENTS - END
7320		- uint64_t return_to = 18446744073709551345LLU;
	7050	+ uint64_t return_to = 18446744073709551353LLU;
7321	7051	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7322	7052	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7323	7053	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7326,32 +7056,32 @@
7326	7056	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7327	7057	break;
7328	7058	}
7329		- case 18446744073709551345LLU: // 999999995v'''''''''''''''
	7059	+ case 18446744073709551353LLU: // 9999999953'''''''''''''''
7330	7060	{
7331	7061	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 9
7332		- state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
	7062	+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
7333	7063	break;
7334	7064	}
7335		- case 18446744073709551348LLU: // 999999995y'''''''''''''''
	7065	+ case 18446744073709551356LLU: // 9999999956'''''''''''''''
7336	7066	{
7337	7067
7338	7068	access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7339		- state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
	7069	+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
7340	7070	break;
7341	7071	}
7342		- case 18446744073709551347LLU: // 999999995x'''''''''''''''
	7072	+ case 18446744073709551355LLU: // 9999999955'''''''''''''''
7343	7073	{
7344	7074	// parameter-reference resdest___ res0______ goes out of scope
7345	7075	// parameter-reference list<resdest___> xresults__ goes out of scope
7346		- state.addr = 18446744073709551351LLU; // 9999999951'''''''''''''''
	7076	+ state.addr = 18446744073709551359LLU; // 9999999959'''''''''''''''
7347	7077	break;
7348	7078	}
7349		- case 18446744073709551350LLU: // 9999999950'''''''''''''''
	7079	+ case 18446744073709551358LLU: // 9999999958'''''''''''''''
7350	7080	{
7351		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551344LLU : 18446744073709551343LLU;
	7081	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551352LLU : 18446744073709551351LLU;
7352	7082	break;
7353	7083	}
7354		- case 18446744073709551344LLU: // 999999995u'''''''''''''''
	7084	+ case 18446744073709551352LLU: // 9999999952'''''''''''''''
7355	7085	{
7356	7086	{
7357	7087	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/list*/, 8);

		@@ -7367,7 +7097,7 @@
7367	7097	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7368	7098	}
7369	7099	// ACCUMULATE ARGUMENTS - END
7370		- uint64_t return_to = 18446744073709551341LLU;
	7100	+ uint64_t return_to = 18446744073709551349LLU;
7371	7101	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7372	7102	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7373	7103	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7376,29 +7106,29 @@
7376	7106	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7377	7107	break;
7378	7108	}
7379		- case 18446744073709551341LLU: // 999999995r'''''''''''''''
	7109	+ case 18446744073709551349LLU: // 999999995z'''''''''''''''
7380	7110	{
7381	7111	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 7
7382		- state.addr = 18446744073709551342LLU; // 999999995s'''''''''''''''
	7112	+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
7383	7113	break;
7384	7114	}
7385		- case 18446744073709551343LLU: // 999999995t'''''''''''''''
	7115	+ case 18446744073709551351LLU: // 9999999951'''''''''''''''
7386	7116	{
7387		- state.addr = 18446744073709551342LLU; // 999999995s'''''''''''''''
	7117	+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
7388	7118	break;
7389	7119	}
7390		- case 18446744073709551342LLU: // 999999995s'''''''''''''''
	7120	+ case 18446744073709551350LLU: // 9999999950'''''''''''''''
7391	7121	{
7392	7122	// variable list<resdest___> yres______ goes out of scope
7393	7123	// emitted destructur for type list<resdest___>
7394		- state.addr = 18446744073709551339LLU; // 999999995p'''''''''''''''
	7124	+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7395	7125	break;
7396	7126	}
7397		- case 18446744073709551339LLU: // 999999995p'''''''''''''''
	7127	+ case 18446744073709551347LLU: // 999999995x'''''''''''''''
7398	7128	{
7399	7129	if(!LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/list*/)
7400	7130	{
7401		- state.addr = 18446744073709551340LLU; // 999999995q'''''''''''''''
	7131	+ state.addr = 18446744073709551348LLU; // 999999995y'''''''''''''''
7402	7132	break;
7403	7133	}
7404	7134	// temporary list-element

		@@ -7412,7 +7142,7 @@
7412	7142	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7413	7143	}
7414	7144	// ACCUMULATE ARGUMENTS - END
7415		- uint64_t return_to = 18446744073709551338LLU;
	7145	+ uint64_t return_to = 18446744073709551346LLU;
7416	7146	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7417	7147	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7418	7148	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7421,14 +7151,14 @@
7421	7151	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7422	7152	break;
7423	7153	}
7424		- case 18446744073709551338LLU: // 999999995o'''''''''''''''
	7154	+ case 18446744073709551346LLU: // 999999995w'''''''''''''''
7425	7155	{
7426	7156	// RELEASE temporary destructor-variable
7427	7157	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7428		- state.addr = 18446744073709551339LLU; // 999999995p'''''''''''''''
	7158	+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7429	7159	break;
7430	7160	}
7431		- case 18446744073709551340LLU: // 999999995q'''''''''''''''
	7161	+ case 18446744073709551348LLU: // 999999995y'''''''''''''''
7432	7162	{
7433	7163	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference yres______ at 6
7434	7164	{

		@@ -7443,10 +7173,10 @@
7443	7173	uint64_t arg = 0;
7444	7174	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
7445	7175	}
7446		- state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
	7176	+ state.addr = 18446744073709551345LLU; // 999999995v'''''''''''''''
7447	7177	break;
7448	7178	}
7449		- case 18446744073709551337LLU: // 999999995n'''''''''''''''
	7179	+ case 18446744073709551345LLU: // 999999995v'''''''''''''''
7450	7180	{
7451	7181	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7452	7182	{

		@@ -7453,7 +7183,7 @@
7453	7183	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
7454	7184	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7455	7185	{
7456		- state.addr = 18446744073709551336LLU; // 999999995m'''''''''''''''
	7186	+ state.addr = 18446744073709551344LLU; // 999999995u'''''''''''''''
7457	7187	break;
7458	7188	}
7459	7189	}

		@@ -7473,7 +7203,7 @@
7473	7203	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7474	7204	}
7475	7205	// ACCUMULATE ARGUMENTS - END
7476		- uint64_t return_to = 18446744073709551332LLU;
	7206	+ uint64_t return_to = 18446744073709551340LLU;
7477	7207	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
7478	7208	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7479	7209	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7482,12 +7212,12 @@
7482	7212	state.addr = 296309897384864500LLU; // ParDefCopy
7483	7213	break;
7484	7214	}
7485		- case 18446744073709551332LLU: // 999999995i'''''''''''''''
	7215	+ case 18446744073709551340LLU: // 999999995q'''''''''''''''
7486	7216	{
7487		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551335LLU : 18446744073709551334LLU;
	7217	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551343LLU : 18446744073709551342LLU;
7488	7218	break;
7489	7219	}
7490		- case 18446744073709551335LLU: // 999999995l'''''''''''''''
	7220	+ case 18446744073709551343LLU: // 999999995t'''''''''''''''
7491	7221	{
7492	7222	{
7493	7223	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -7500,35 +7230,35 @@
7500	7230	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7501	7231	}
7502	7232	// ACCUMULATE ARGUMENTS - END
7503		- uint64_t return_to = 18446744073709551331LLU;
	7233	+ uint64_t return_to = 18446744073709551339LLU;
7504	7234	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7505	7235	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7506	7236	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7507	7237	heap.data[0].elem1 = heap.data[0].elem0;
7508	7238	heap.data[0].elem0 = restore;
7509		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7239	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7510	7240	break;
7511	7241	}
7512		- case 18446744073709551331LLU: // 999999995h'''''''''''''''
	7242	+ case 18446744073709551339LLU: // 999999995p'''''''''''''''
7513	7243	{
7514	7244	// parameter pardef____ new_______ goes out of scope
7515		- state.addr = 18446744073709551333LLU; // 999999995j'''''''''''''''
	7245	+ state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
7516	7246	break;
7517	7247	}
7518		- case 18446744073709551334LLU: // 999999995k'''''''''''''''
	7248	+ case 18446744073709551342LLU: // 999999995s'''''''''''''''
7519	7249	{
7520		- state.addr = 18446744073709551333LLU; // 999999995j'''''''''''''''
	7250	+ state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
7521	7251	break;
7522	7252	}
7523		- case 18446744073709551333LLU: // 999999995j'''''''''''''''
	7253	+ case 18446744073709551341LLU: // 999999995r'''''''''''''''
7524	7254	{
7525	7255	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
7526	7256	// parameter-reference pardef____ par1______ goes out of scope
7527	7257	// parameter-reference list<pardef____> ydefpars__ goes out of scope
7528		- state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
	7258	+ state.addr = 18446744073709551345LLU; // 999999995v'''''''''''''''
7529	7259	break;
7530	7260	}
7531		- case 18446744073709551336LLU: // 999999995m'''''''''''''''
	7261	+ case 18446744073709551344LLU: // 999999995u'''''''''''''''
7532	7262	{
7533	7263	list_reverse(heap.data, &/ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
7534	7264	{

		@@ -7539,10 +7269,10 @@
7539	7269	uint64_t arg = 0;
7540	7270	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
7541	7271	}
7542		- state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
	7272	+ state.addr = 18446744073709551338LLU; // 999999995o'''''''''''''''
7543	7273	break;
7544	7274	}
7545		- case 18446744073709551330LLU: // 999999995g'''''''''''''''
	7275	+ case 18446744073709551338LLU: // 999999995o'''''''''''''''
7546	7276	{
7547	7277	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7548	7278	{

		@@ -7549,16 +7279,16 @@
7549	7279	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
7550	7280	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7551	7281	{
7552		- state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
	7282	+ state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
7553	7283	break;
7554	7284	}
7555	7285	}
7556	7286	/direct/LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7557	7287	LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7558		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551328LLU : 18446744073709551327LLU;
	7288	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551336LLU : 18446744073709551335LLU;
7559	7289	break;
7560	7290	}
7561		- case 18446744073709551328LLU: // 999999995e'''''''''''''''
	7291	+ case 18446744073709551336LLU: // 999999995m'''''''''''''''
7562	7292	{
7563	7293	{
7564	7294	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/list*/, 11);

		@@ -7583,7 +7313,7 @@
7583	7313	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7584	7314	}
7585	7315	// ACCUMULATE ARGUMENTS - END
7586		- uint64_t return_to = 18446744073709551325LLU;
	7316	+ uint64_t return_to = 18446744073709551333LLU;
7587	7317	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
7588	7318	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7589	7319	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7592,7 +7322,7 @@
7592	7322	state.addr = 589059743276730432LLU; // equpardef_
7593	7323	break;
7594	7324	}
7595		- case 18446744073709551325LLU: // 999999995b'''''''''''''''
	7325	+ case 18446744073709551333LLU: // 999999995j'''''''''''''''
7596	7326	{
7597	7327
7598	7328	access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU);

		@@ -7607,41 +7337,41 @@
7607	7337	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7608	7338	}
7609	7339	// ACCUMULATE ARGUMENTS - END
7610		- uint64_t return_to = 18446744073709551324LLU;
	7340	+ uint64_t return_to = 18446744073709551332LLU;
7611	7341	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7612	7342	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7613	7343	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7614	7344	heap.data[0].elem1 = heap.data[0].elem0;
7615	7345	heap.data[0].elem0 = restore;
7616		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7346	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7617	7347	break;
7618	7348	}
7619		- case 18446744073709551324LLU: // 999999995a'''''''''''''''
	7349	+ case 18446744073709551332LLU: // 999999995i'''''''''''''''
7620	7350	{
7621	7351	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 9
7622		- state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
	7352	+ state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
7623	7353	break;
7624	7354	}
7625		- case 18446744073709551327LLU: // 999999995d'''''''''''''''
	7355	+ case 18446744073709551335LLU: // 999999995l'''''''''''''''
7626	7356	{
7627	7357
7628	7358	access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7629		- state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
	7359	+ state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
7630	7360	break;
7631	7361	}
7632		- case 18446744073709551326LLU: // 999999995c'''''''''''''''
	7362	+ case 18446744073709551334LLU: // 999999995k'''''''''''''''
7633	7363	{
7634	7364	// parameter-reference pardef____ par0______ goes out of scope
7635	7365	// parameter-reference list<pardef____> xdefpars__ goes out of scope
7636		- state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
	7366	+ state.addr = 18446744073709551338LLU; // 999999995o'''''''''''''''
7637	7367	break;
7638	7368	}
7639		- case 18446744073709551329LLU: // 999999995f'''''''''''''''
	7369	+ case 18446744073709551337LLU: // 999999995n'''''''''''''''
7640	7370	{
7641		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551323LLU : 18446744073709551322LLU;
	7371	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551331LLU : 18446744073709551330LLU;
7642	7372	break;
7643	7373	}
7644		- case 18446744073709551323LLU: // 999999995$'''''''''''''''
	7374	+ case 18446744073709551331LLU: // 999999995h'''''''''''''''
7645	7375	{
7646	7376	{
7647	7377	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/list*/, 11);

		@@ -7657,38 +7387,38 @@
7657	7387	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7658	7388	}
7659	7389	// ACCUMULATE ARGUMENTS - END
7660		- uint64_t return_to = 18446744073709551320LLU;
	7390	+ uint64_t return_to = 18446744073709551328LLU;
7661	7391	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7662	7392	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7663	7393	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7664	7394	heap.data[0].elem1 = heap.data[0].elem0;
7665	7395	heap.data[0].elem0 = restore;
7666		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7396	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7667	7397	break;
7668	7398	}
7669		- case 18446744073709551320LLU: // 999999995X'''''''''''''''
	7399	+ case 18446744073709551328LLU: // 999999995e'''''''''''''''
7670	7400	{
7671	7401	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 7
7672		- state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
	7402	+ state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
7673	7403	break;
7674	7404	}
7675		- case 18446744073709551322LLU: // 999999995Z'''''''''''''''
	7405	+ case 18446744073709551330LLU: // 999999995g'''''''''''''''
7676	7406	{
7677		- state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
	7407	+ state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
7678	7408	break;
7679	7409	}
7680		- case 18446744073709551321LLU: // 999999995Y'''''''''''''''
	7410	+ case 18446744073709551329LLU: // 999999995f'''''''''''''''
7681	7411	{
7682	7412	// variable list<pardef____> ypars_____ goes out of scope
7683	7413	// emitted destructur for type list<pardef____>
7684		- state.addr = 18446744073709551318LLU; // 999999995V'''''''''''''''
	7414	+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7685	7415	break;
7686	7416	}
7687		- case 18446744073709551318LLU: // 999999995V'''''''''''''''
	7417	+ case 18446744073709551326LLU: // 999999995c'''''''''''''''
7688	7418	{
7689	7419	if(!LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/list*/)
7690	7420	{
7691		- state.addr = 18446744073709551319LLU; // 999999995W'''''''''''''''
	7421	+ state.addr = 18446744073709551327LLU; // 999999995d'''''''''''''''
7692	7422	break;
7693	7423	}
7694	7424	// temporary list-element

		@@ -7702,23 +7432,23 @@
7702	7432	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7703	7433	}
7704	7434	// ACCUMULATE ARGUMENTS - END
7705		- uint64_t return_to = 18446744073709551317LLU;
	7435	+ uint64_t return_to = 18446744073709551325LLU;
7706	7436	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7707	7437	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7708	7438	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7709	7439	heap.data[0].elem1 = heap.data[0].elem0;
7710	7440	heap.data[0].elem0 = restore;
7711		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7441	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7712	7442	break;
7713	7443	}
7714		- case 18446744073709551317LLU: // 999999995U'''''''''''''''
	7444	+ case 18446744073709551325LLU: // 999999995b'''''''''''''''
7715	7445	{
7716	7446	// RELEASE temporary destructor-variable
7717	7447	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
7718		- state.addr = 18446744073709551318LLU; // 999999995V'''''''''''''''
	7448	+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7719	7449	break;
7720	7450	}
7721		- case 18446744073709551319LLU: // 999999995W'''''''''''''''
	7451	+ case 18446744073709551327LLU: // 999999995d'''''''''''''''
7722	7452	{
7723	7453	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ypars_____ at 6
7724	7454	// parameter-reference list<pardef____> ydefpars__ goes out of scope

		@@ -7755,10 +7485,10 @@
7755	7485	uint64_t arg = 0;
7756	7486	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
7757	7487	}
7758		- state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	7488	+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
7759	7489	break;
7760	7490	}
7761		- case 18446744073709551316LLU: // 999999995T'''''''''''''''
	7491	+ case 18446744073709551324LLU: // 999999995a'''''''''''''''
7762	7492	{
7763	7493	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7764	7494	{

		@@ -7765,7 +7495,7 @@
7765	7495	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
7766	7496	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
7767	7497	{
7768		- state.addr = 18446744073709551315LLU; // 999999995S'''''''''''''''
	7498	+ state.addr = 18446744073709551323LLU; // 999999995$'''''''''''''''
7769	7499	break;
7770	7500	}
7771	7501	}

		@@ -7785,7 +7515,7 @@
7785	7515	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7786	7516	}
7787	7517	// ACCUMULATE ARGUMENTS - END
7788		- uint64_t return_to = 18446744073709551311LLU;
	7518	+ uint64_t return_to = 18446744073709551319LLU;
7789	7519	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
7790	7520	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7791	7521	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7794,12 +7524,12 @@
7794	7524	state.addr = 325750391286068249LLU; // RESDEFCOPY
7795	7525	break;
7796	7526	}
7797		- case 18446744073709551311LLU: // 999999995O'''''''''''''''
	7527	+ case 18446744073709551319LLU: // 999999995W'''''''''''''''
7798	7528	{
7799		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551314LLU : 18446744073709551313LLU;
	7529	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551322LLU : 18446744073709551321LLU;
7800	7530	break;
7801	7531	}
7802		- case 18446744073709551314LLU: // 999999995R'''''''''''''''
	7532	+ case 18446744073709551322LLU: // 999999995Z'''''''''''''''
7803	7533	{
7804	7534	{
7805	7535	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -7812,7 +7542,7 @@
7812	7542	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7813	7543	}
7814	7544	// ACCUMULATE ARGUMENTS - END
7815		- uint64_t return_to = 18446744073709551310LLU;
	7545	+ uint64_t return_to = 18446744073709551318LLU;
7816	7546	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7817	7547	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7818	7548	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7821,26 +7551,26 @@
7821	7551	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7822	7552	break;
7823	7553	}
7824		- case 18446744073709551310LLU: // 999999995N'''''''''''''''
	7554	+ case 18446744073709551318LLU: // 999999995V'''''''''''''''
7825	7555	{
7826	7556	// parameter resdest___ new_______ goes out of scope
7827		- state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
	7557	+ state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
7828	7558	break;
7829	7559	}
7830		- case 18446744073709551313LLU: // 999999995Q'''''''''''''''
	7560	+ case 18446744073709551321LLU: // 999999995Y'''''''''''''''
7831	7561	{
7832		- state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
	7562	+ state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
7833	7563	break;
7834	7564	}
7835		- case 18446744073709551312LLU: // 999999995P'''''''''''''''
	7565	+ case 18446744073709551320LLU: // 999999995X'''''''''''''''
7836	7566	{
7837	7567	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
7838	7568	// parameter-reference resdest___ respar1___ goes out of scope
7839	7569	// parameter-reference list<resdest___> yresults__ goes out of scope
7840		- state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	7570	+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
7841	7571	break;
7842	7572	}
7843		- case 18446744073709551315LLU: // 999999995S'''''''''''''''
	7573	+ case 18446744073709551323LLU: // 999999995$'''''''''''''''
7844	7574	{
7845	7575	list_reverse(heap.data, &/yres______/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
7846	7576	{

		@@ -7851,10 +7581,10 @@
7851	7581	uint64_t arg = 0;
7852	7582	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
7853	7583	}
7854		- state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	7584	+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
7855	7585	break;
7856	7586	}
7857		- case 18446744073709551309LLU: // 999999995M'''''''''''''''
	7587	+ case 18446744073709551317LLU: // 999999995U'''''''''''''''
7858	7588	{
7859	7589	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7860	7590	{

		@@ -7861,16 +7591,16 @@
7861	7591	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
7862	7592	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
7863	7593	{
7864		- state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
	7594	+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
7865	7595	break;
7866	7596	}
7867	7597	}
7868	7598	/direct/LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7869	7599	LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7870		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551307LLU : 18446744073709551306LLU;
	7600	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551315LLU : 18446744073709551314LLU;
7871	7601	break;
7872	7602	}
7873		- case 18446744073709551307LLU: // 999999995K'''''''''''''''
	7603	+ case 18446744073709551315LLU: // 999999995S'''''''''''''''
7874	7604	{
7875	7605	{
7876	7606	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/list*/, 8);

		@@ -7895,7 +7625,7 @@
7895	7625	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7896	7626	}
7897	7627	// ACCUMULATE ARGUMENTS - END
7898		- uint64_t return_to = 18446744073709551304LLU;
	7628	+ uint64_t return_to = 18446744073709551312LLU;
7899	7629	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
7900	7630	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7901	7631	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7904,7 +7634,7 @@
7904	7634	state.addr = 589059885019168768LLU; // equres____
7905	7635	break;
7906	7636	}
7907		- case 18446744073709551304LLU: // 999999995H'''''''''''''''
	7637	+ case 18446744073709551312LLU: // 999999995P'''''''''''''''
7908	7638	{
7909	7639
7910	7640	access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);

		@@ -7919,7 +7649,7 @@
7919	7649	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7920	7650	}
7921	7651	// ACCUMULATE ARGUMENTS - END
7922		- uint64_t return_to = 18446744073709551303LLU;
	7652	+ uint64_t return_to = 18446744073709551311LLU;
7923	7653	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7924	7654	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7925	7655	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7928,32 +7658,32 @@
7928	7658	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7929	7659	break;
7930	7660	}
7931		- case 18446744073709551303LLU: // 999999995G'''''''''''''''
	7661	+ case 18446744073709551311LLU: // 999999995O'''''''''''''''
7932	7662	{
7933	7663	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 19
7934		- state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
	7664	+ state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
7935	7665	break;
7936	7666	}
7937		- case 18446744073709551306LLU: // 999999995J'''''''''''''''
	7667	+ case 18446744073709551314LLU: // 999999995R'''''''''''''''
7938	7668	{
7939	7669
7940	7670	access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
7941		- state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
	7671	+ state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
7942	7672	break;
7943	7673	}
7944		- case 18446744073709551305LLU: // 999999995I'''''''''''''''
	7674	+ case 18446744073709551313LLU: // 999999995Q'''''''''''''''
7945	7675	{
7946	7676	// parameter-reference resdest___ res0______ goes out of scope
7947	7677	// parameter-reference list<resdest___> xresults__ goes out of scope
7948		- state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	7678	+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
7949	7679	break;
7950	7680	}
7951		- case 18446744073709551308LLU: // 999999995L'''''''''''''''
	7681	+ case 18446744073709551316LLU: // 999999995T'''''''''''''''
7952	7682	{
7953		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551302LLU : 18446744073709551301LLU;
	7683	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551310LLU : 18446744073709551309LLU;
7954	7684	break;
7955	7685	}
7956		- case 18446744073709551302LLU: // 999999995F'''''''''''''''
	7686	+ case 18446744073709551310LLU: // 999999995N'''''''''''''''
7957	7687	{
7958	7688	{
7959	7689	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/list*/, 8);

		@@ -7969,7 +7699,7 @@
7969	7699	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7970	7700	}
7971	7701	// ACCUMULATE ARGUMENTS - END
7972		- uint64_t return_to = 18446744073709551299LLU;
	7702	+ uint64_t return_to = 18446744073709551307LLU;
7973	7703	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
7974	7704	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7975	7705	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -7978,29 +7708,29 @@
7978	7708	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7979	7709	break;
7980	7710	}
7981		- case 18446744073709551299LLU: // 999999995C'''''''''''''''
	7711	+ case 18446744073709551307LLU: // 999999995K'''''''''''''''
7982	7712	{
7983	7713	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 17
7984		- state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
	7714	+ state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
7985	7715	break;
7986	7716	}
7987		- case 18446744073709551301LLU: // 999999995E'''''''''''''''
	7717	+ case 18446744073709551309LLU: // 999999995M'''''''''''''''
7988	7718	{
7989		- state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
	7719	+ state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
7990	7720	break;
7991	7721	}
7992		- case 18446744073709551300LLU: // 999999995D'''''''''''''''
	7722	+ case 18446744073709551308LLU: // 999999995L'''''''''''''''
7993	7723	{
7994	7724	// variable list<resdest___> yres______ goes out of scope
7995	7725	// emitted destructur for type list<resdest___>
7996		- state.addr = 18446744073709551297LLU; // 999999995A'''''''''''''''
	7726	+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
7997	7727	break;
7998	7728	}
7999		- case 18446744073709551297LLU: // 999999995A'''''''''''''''
	7729	+ case 18446744073709551305LLU: // 999999995I'''''''''''''''
8000	7730	{
8001	7731	if(!LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/list*/)
8002	7732	{
8003		- state.addr = 18446744073709551298LLU; // 999999995B'''''''''''''''
	7733	+ state.addr = 18446744073709551306LLU; // 999999995J'''''''''''''''
8004	7734	break;
8005	7735	}
8006	7736	// temporary list-element

		@@ -8014,7 +7744,7 @@
8014	7744	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8015	7745	}
8016	7746	// ACCUMULATE ARGUMENTS - END
8017		- uint64_t return_to = 18446744073709551296LLU;
	7747	+ uint64_t return_to = 18446744073709551304LLU;
8018	7748	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8019	7749	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8020	7750	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8023,14 +7753,14 @@
8023	7753	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8024	7754	break;
8025	7755	}
8026		- case 18446744073709551296LLU: // 999999995_'''''''''''''''
	7756	+ case 18446744073709551304LLU: // 999999995H'''''''''''''''
8027	7757	{
8028	7758	// RELEASE temporary destructor-variable
8029	7759	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
8030		- state.addr = 18446744073709551297LLU; // 999999995A'''''''''''''''
	7760	+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
8031	7761	break;
8032	7762	}
8033		- case 18446744073709551298LLU: // 999999995B'''''''''''''''
	7763	+ case 18446744073709551306LLU: // 999999995J'''''''''''''''
8034	7764	{
8035	7765	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference yres______ at 16
8036	7766	{

		@@ -8045,10 +7775,10 @@
8045	7775	uint64_t arg = 0;
8046	7776	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
8047	7777	}
8048		- state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
	7778	+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
8049	7779	break;
8050	7780	}
8051		- case 18446744073709551295LLU: // 9999999949'''''''''''''''
	7781	+ case 18446744073709551303LLU: // 999999995G'''''''''''''''
8052	7782	{
8053	7783	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
8054	7784	{

		@@ -8055,7 +7785,7 @@
8055	7785	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
8056	7786	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
8057	7787	{
8058		- state.addr = 18446744073709551294LLU; // 9999999948'''''''''''''''
	7788	+ state.addr = 18446744073709551302LLU; // 999999995F'''''''''''''''
8059	7789	break;
8060	7790	}
8061	7791	}

		@@ -8075,7 +7805,7 @@
8075	7805	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8076	7806	}
8077	7807	// ACCUMULATE ARGUMENTS - END
8078		- uint64_t return_to = 18446744073709551290LLU;
	7808	+ uint64_t return_to = 18446744073709551298LLU;
8079	7809	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
8080	7810	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8081	7811	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8084,12 +7814,12 @@
8084	7814	state.addr = 296309897384864500LLU; // ParDefCopy
8085	7815	break;
8086	7816	}
8087		- case 18446744073709551290LLU: // 9999999944'''''''''''''''
	7817	+ case 18446744073709551298LLU: // 999999995B'''''''''''''''
8088	7818	{
8089		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551293LLU : 18446744073709551292LLU;
	7819	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551301LLU : 18446744073709551300LLU;
8090	7820	break;
8091	7821	}
8092		- case 18446744073709551293LLU: // 9999999947'''''''''''''''
	7822	+ case 18446744073709551301LLU: // 999999995E'''''''''''''''
8093	7823	{
8094	7824	{
8095	7825	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -8102,35 +7832,35 @@
8102	7832	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8103	7833	}
8104	7834	// ACCUMULATE ARGUMENTS - END
8105		- uint64_t return_to = 18446744073709551289LLU;
	7835	+ uint64_t return_to = 18446744073709551297LLU;
8106	7836	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8107	7837	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8108	7838	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8109	7839	heap.data[0].elem1 = heap.data[0].elem0;
8110	7840	heap.data[0].elem0 = restore;
8111		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7841	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8112	7842	break;
8113	7843	}
8114		- case 18446744073709551289LLU: // 9999999943'''''''''''''''
	7844	+ case 18446744073709551297LLU: // 999999995A'''''''''''''''
8115	7845	{
8116	7846	// parameter pardef____ new_______ goes out of scope
8117		- state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
	7847	+ state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
8118	7848	break;
8119	7849	}
8120		- case 18446744073709551292LLU: // 9999999946'''''''''''''''
	7850	+ case 18446744073709551300LLU: // 999999995D'''''''''''''''
8121	7851	{
8122		- state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
	7852	+ state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
8123	7853	break;
8124	7854	}
8125		- case 18446744073709551291LLU: // 9999999945'''''''''''''''
	7855	+ case 18446744073709551299LLU: // 999999995C'''''''''''''''
8126	7856	{
8127	7857	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
8128	7858	// parameter-reference pardef____ par1______ goes out of scope
8129	7859	// parameter-reference list<pardef____> ydefpars__ goes out of scope
8130		- state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
	7860	+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
8131	7861	break;
8132	7862	}
8133		- case 18446744073709551294LLU: // 9999999948'''''''''''''''
	7863	+ case 18446744073709551302LLU: // 999999995F'''''''''''''''
8134	7864	{
8135	7865	list_reverse(heap.data, &/ypars_____/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
8136	7866	{

		@@ -8141,10 +7871,10 @@
8141	7871	uint64_t arg = 0;
8142	7872	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
8143	7873	}
8144		- state.addr = 18446744073709551288LLU; // 9999999942'''''''''''''''
	7874	+ state.addr = 18446744073709551296LLU; // 999999995_'''''''''''''''
8145	7875	break;
8146	7876	}
8147		- case 18446744073709551288LLU: // 9999999942'''''''''''''''
	7877	+ case 18446744073709551296LLU: // 999999995_'''''''''''''''
8148	7878	{
8149	7879	if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
8150	7880	{

		@@ -8151,16 +7881,16 @@
8151	7881	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
8152	7882	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
8153	7883	{
8154		- state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
	7884	+ state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
8155	7885	break;
8156	7886	}
8157	7887	}
8158	7888	/direct/LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
8159	7889	LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
8160		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551286LLU : 18446744073709551285LLU;
	7890	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551294LLU : 18446744073709551293LLU;
8161	7891	break;
8162	7892	}
8163		- case 18446744073709551286LLU: // 9999999940'''''''''''''''
	7893	+ case 18446744073709551294LLU: // 9999999948'''''''''''''''
8164	7894	{
8165	7895	{
8166	7896	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/list*/, 11);

		@@ -8185,7 +7915,7 @@
8185	7915	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8186	7916	}
8187	7917	// ACCUMULATE ARGUMENTS - END
8188		- uint64_t return_to = 18446744073709551283LLU;
	7918	+ uint64_t return_to = 18446744073709551291LLU;
8189	7919	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
8190	7920	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8191	7921	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8194,7 +7924,7 @@
8194	7924	state.addr = 589059743276730432LLU; // equpardef_
8195	7925	break;
8196	7926	}
8197		- case 18446744073709551283LLU: // 999999994x'''''''''''''''
	7927	+ case 18446744073709551291LLU: // 9999999945'''''''''''''''
8198	7928	{
8199	7929
8200	7930	access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);

		@@ -8209,41 +7939,41 @@
8209	7939	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8210	7940	}
8211	7941	// ACCUMULATE ARGUMENTS - END
8212		- uint64_t return_to = 18446744073709551282LLU;
	7942	+ uint64_t return_to = 18446744073709551290LLU;
8213	7943	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8214	7944	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8215	7945	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8216	7946	heap.data[0].elem1 = heap.data[0].elem0;
8217	7947	heap.data[0].elem0 = restore;
8218		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7948	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8219	7949	break;
8220	7950	}
8221		- case 18446744073709551282LLU: // 999999994w'''''''''''''''
	7951	+ case 18446744073709551290LLU: // 9999999944'''''''''''''''
8222	7952	{
8223	7953	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 19
8224		- state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
	7954	+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
8225	7955	break;
8226	7956	}
8227		- case 18446744073709551285LLU: // 999999994z'''''''''''''''
	7957	+ case 18446744073709551293LLU: // 9999999947'''''''''''''''
8228	7958	{
8229	7959
8230	7960	access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
8231		- state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
	7961	+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
8232	7962	break;
8233	7963	}
8234		- case 18446744073709551284LLU: // 999999994y'''''''''''''''
	7964	+ case 18446744073709551292LLU: // 9999999946'''''''''''''''
8235	7965	{
8236	7966	// parameter-reference pardef____ par0______ goes out of scope
8237	7967	// parameter-reference list<pardef____> xdefpars__ goes out of scope
8238		- state.addr = 18446744073709551288LLU; // 9999999942'''''''''''''''
	7968	+ state.addr = 18446744073709551296LLU; // 999999995_'''''''''''''''
8239	7969	break;
8240	7970	}
8241		- case 18446744073709551287LLU: // 9999999941'''''''''''''''
	7971	+ case 18446744073709551295LLU: // 9999999949'''''''''''''''
8242	7972	{
8243		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551281LLU : 18446744073709551280LLU;
	7973	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551289LLU : 18446744073709551288LLU;
8244	7974	break;
8245	7975	}
8246		- case 18446744073709551281LLU: // 999999994v'''''''''''''''
	7976	+ case 18446744073709551289LLU: // 9999999943'''''''''''''''
8247	7977	{
8248	7978	{
8249	7979	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/list*/, 11);

		@@ -8259,38 +7989,38 @@
8259	7989	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8260	7990	}
8261	7991	// ACCUMULATE ARGUMENTS - END
8262		- uint64_t return_to = 18446744073709551278LLU;
	7992	+ uint64_t return_to = 18446744073709551286LLU;
8263	7993	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8264	7994	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8265	7995	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8266	7996	heap.data[0].elem1 = heap.data[0].elem0;
8267	7997	heap.data[0].elem0 = restore;
8268		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	7998	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8269	7999	break;
8270	8000	}
8271		- case 18446744073709551278LLU: // 999999994s'''''''''''''''
	8001	+ case 18446744073709551286LLU: // 9999999940'''''''''''''''
8272	8002	{
8273	8003	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 17
8274		- state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
	8004	+ state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
8275	8005	break;
8276	8006	}
8277		- case 18446744073709551280LLU: // 999999994u'''''''''''''''
	8007	+ case 18446744073709551288LLU: // 9999999942'''''''''''''''
8278	8008	{
8279		- state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
	8009	+ state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
8280	8010	break;
8281	8011	}
8282		- case 18446744073709551279LLU: // 999999994t'''''''''''''''
	8012	+ case 18446744073709551287LLU: // 9999999941'''''''''''''''
8283	8013	{
8284	8014	// variable list<pardef____> ypars_____ goes out of scope
8285	8015	// emitted destructur for type list<pardef____>
8286		- state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
	8016	+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8287	8017	break;
8288	8018	}
8289		- case 18446744073709551276LLU: // 999999994q'''''''''''''''
	8019	+ case 18446744073709551284LLU: // 999999994y'''''''''''''''
8290	8020	{
8291	8021	if(!LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/list*/)
8292	8022	{
8293		- state.addr = 18446744073709551277LLU; // 999999994r'''''''''''''''
	8023	+ state.addr = 18446744073709551285LLU; // 999999994z'''''''''''''''
8294	8024	break;
8295	8025	}
8296	8026	// temporary list-element

		@@ -8304,23 +8034,23 @@
8304	8034	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8305	8035	}
8306	8036	// ACCUMULATE ARGUMENTS - END
8307		- uint64_t return_to = 18446744073709551275LLU;
	8037	+ uint64_t return_to = 18446744073709551283LLU;
8308	8038	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8309	8039	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8310	8040	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8311	8041	heap.data[0].elem1 = heap.data[0].elem0;
8312	8042	heap.data[0].elem0 = restore;
8313		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	8043	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8314	8044	break;
8315	8045	}
8316		- case 18446744073709551275LLU: // 999999994p'''''''''''''''
	8046	+ case 18446744073709551283LLU: // 999999994x'''''''''''''''
8317	8047	{
8318	8048	// RELEASE temporary destructor-variable
8319	8049	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 17
8320		- state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
	8050	+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8321	8051	break;
8322	8052	}
8323		- case 18446744073709551277LLU: // 999999994r'''''''''''''''
	8053	+ case 18446744073709551285LLU: // 999999994z'''''''''''''''
8324	8054	{
8325	8055	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ypars_____ at 16
8326	8056	{

		@@ -8427,10 +8157,10 @@
8427	8157	uint64_t arg = 0;
8428	8158	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
8429	8159	}
8430		- state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
	8160	+ state.addr = 18446744073709551282LLU; // 999999994w'''''''''''''''
8431	8161	break;
8432	8162	}
8433		- case 18446744073709551274LLU: // 999999994o'''''''''''''''
	8163	+ case 18446744073709551282LLU: // 999999994w'''''''''''''''
8434	8164	{
8435	8165	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8436	8166	{

		@@ -8437,7 +8167,7 @@
8437	8167	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8438	8168	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8439	8169	{
8440		- state.addr = 18446744073709551273LLU; // 999999994n'''''''''''''''
	8170	+ state.addr = 18446744073709551281LLU; // 999999994v'''''''''''''''
8441	8171	break;
8442	8172	}
8443	8173	}

		@@ -8457,7 +8187,7 @@
8457	8187	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8458	8188	}
8459	8189	// ACCUMULATE ARGUMENTS - END
8460		- uint64_t return_to = 18446744073709551269LLU;
	8190	+ uint64_t return_to = 18446744073709551277LLU;
8461	8191	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
8462	8192	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8463	8193	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8466,12 +8196,12 @@
8466	8196	state.addr = 325750391286068249LLU; // RESDEFCOPY
8467	8197	break;
8468	8198	}
8469		- case 18446744073709551269LLU: // 999999994j'''''''''''''''
	8199	+ case 18446744073709551277LLU: // 999999994r'''''''''''''''
8470	8200	{
8471		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551272LLU : 18446744073709551271LLU;
	8201	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551280LLU : 18446744073709551279LLU;
8472	8202	break;
8473	8203	}
8474		- case 18446744073709551272LLU: // 999999994m'''''''''''''''
	8204	+ case 18446744073709551280LLU: // 999999994u'''''''''''''''
8475	8205	{
8476	8206	{
8477	8207	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -8484,7 +8214,7 @@
8484	8214	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8485	8215	}
8486	8216	// ACCUMULATE ARGUMENTS - END
8487		- uint64_t return_to = 18446744073709551268LLU;
	8217	+ uint64_t return_to = 18446744073709551276LLU;
8488	8218	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8489	8219	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8490	8220	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8493,26 +8223,26 @@
8493	8223	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8494	8224	break;
8495	8225	}
8496		- case 18446744073709551268LLU: // 999999994i'''''''''''''''
	8226	+ case 18446744073709551276LLU: // 999999994q'''''''''''''''
8497	8227	{
8498	8228	// parameter resdest___ new_______ goes out of scope
8499		- state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
	8229	+ state.addr = 18446744073709551278LLU; // 999999994s'''''''''''''''
8500	8230	break;
8501	8231	}
8502		- case 18446744073709551271LLU: // 999999994l'''''''''''''''
	8232	+ case 18446744073709551279LLU: // 999999994t'''''''''''''''
8503	8233	{
8504		- state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
	8234	+ state.addr = 18446744073709551278LLU; // 999999994s'''''''''''''''
8505	8235	break;
8506	8236	}
8507		- case 18446744073709551270LLU: // 999999994k'''''''''''''''
	8237	+ case 18446744073709551278LLU: // 999999994s'''''''''''''''
8508	8238	{
8509	8239	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8510	8240	// parameter-reference resdest___ respar1___ goes out of scope
8511	8241	// parameter-reference function__ y_________ goes out of scope
8512		- state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
	8242	+ state.addr = 18446744073709551282LLU; // 999999994w'''''''''''''''
8513	8243	break;
8514	8244	}
8515		- case 18446744073709551273LLU: // 999999994n'''''''''''''''
	8245	+ case 18446744073709551281LLU: // 999999994v'''''''''''''''
8516	8246	{
8517	8247	list_reverse(heap.data, &/yres______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
8518	8248	{

		@@ -8523,10 +8253,10 @@
8523	8253	uint64_t arg = 0;
8524	8254	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
8525	8255	}
8526		- state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
	8256	+ state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
8527	8257	break;
8528	8258	}
8529		- case 18446744073709551267LLU: // 999999994h'''''''''''''''
	8259	+ case 18446744073709551275LLU: // 999999994p'''''''''''''''
8530	8260	{
8531	8261	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8532	8262	{

		@@ -8533,16 +8263,16 @@
8533	8263	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8534	8264	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8535	8265	{
8536		- state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
	8266	+ state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
8537	8267	break;
8538	8268	}
8539	8269	}
8540	8270	/direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8541	8271	LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8542		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551265LLU : 18446744073709551264LLU;
	8272	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551273LLU : 18446744073709551272LLU;
8543	8273	break;
8544	8274	}
8545		- case 18446744073709551265LLU: // 999999994f'''''''''''''''
	8275	+ case 18446744073709551273LLU: // 999999994n'''''''''''''''
8546	8276	{
8547	8277	{
8548	8278	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/list*/, 8);

		@@ -8567,7 +8297,7 @@
8567	8297	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8568	8298	}
8569	8299	// ACCUMULATE ARGUMENTS - END
8570		- uint64_t return_to = 18446744073709551262LLU;
	8300	+ uint64_t return_to = 18446744073709551270LLU;
8571	8301	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
8572	8302	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8573	8303	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8576,7 +8306,7 @@
8576	8306	state.addr = 589059885019168768LLU; // equres____
8577	8307	break;
8578	8308	}
8579		- case 18446744073709551262LLU: // 999999994c'''''''''''''''
	8309	+ case 18446744073709551270LLU: // 999999994k'''''''''''''''
8580	8310	{
8581	8311
8582	8312	access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);

		@@ -8591,7 +8321,7 @@
8591	8321	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8592	8322	}
8593	8323	// ACCUMULATE ARGUMENTS - END
8594		- uint64_t return_to = 18446744073709551261LLU;
	8324	+ uint64_t return_to = 18446744073709551269LLU;
8595	8325	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8596	8326	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8597	8327	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8600,32 +8330,32 @@
8600	8330	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8601	8331	break;
8602	8332	}
8603		- case 18446744073709551261LLU: // 999999994b'''''''''''''''
	8333	+ case 18446744073709551269LLU: // 999999994j'''''''''''''''
8604	8334	{
8605	8335	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 7
8606		- state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
	8336	+ state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
8607	8337	break;
8608	8338	}
8609		- case 18446744073709551264LLU: // 999999994e'''''''''''''''
	8339	+ case 18446744073709551272LLU: // 999999994m'''''''''''''''
8610	8340	{
8611	8341
8612	8342	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0;
8613		- state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
	8343	+ state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
8614	8344	break;
8615	8345	}
8616		- case 18446744073709551263LLU: // 999999994d'''''''''''''''
	8346	+ case 18446744073709551271LLU: // 999999994l'''''''''''''''
8617	8347	{
8618	8348	// parameter-reference resdest___ res0______ goes out of scope
8619	8349	// parameter-reference function__ x_________ goes out of scope
8620		- state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
	8350	+ state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
8621	8351	break;
8622	8352	}
8623		- case 18446744073709551266LLU: // 999999994g'''''''''''''''
	8353	+ case 18446744073709551274LLU: // 999999994o'''''''''''''''
8624	8354	{
8625		- state.addr = /yres______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551260LLU : 18446744073709551259LLU;
	8355	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551268LLU : 18446744073709551267LLU;
8626	8356	break;
8627	8357	}
8628		- case 18446744073709551260LLU: // 999999994a'''''''''''''''
	8358	+ case 18446744073709551268LLU: // 999999994i'''''''''''''''
8629	8359	{
8630	8360	{
8631	8361	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/, 8);

		@@ -8641,7 +8371,7 @@
8641	8371	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8642	8372	}
8643	8373	// ACCUMULATE ARGUMENTS - END
8644		- uint64_t return_to = 18446744073709551257LLU;
	8374	+ uint64_t return_to = 18446744073709551265LLU;
8645	8375	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8646	8376	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8647	8377	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8650,29 +8380,29 @@
8650	8380	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8651	8381	break;
8652	8382	}
8653		- case 18446744073709551257LLU: // 999999994Y'''''''''''''''
	8383	+ case 18446744073709551265LLU: // 999999994f'''''''''''''''
8654	8384	{
8655	8385	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 5
8656		- state.addr = 18446744073709551258LLU; // 999999994Z'''''''''''''''
	8386	+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
8657	8387	break;
8658	8388	}
8659		- case 18446744073709551259LLU: // 999999994$'''''''''''''''
	8389	+ case 18446744073709551267LLU: // 999999994h'''''''''''''''
8660	8390	{
8661		- state.addr = 18446744073709551258LLU; // 999999994Z'''''''''''''''
	8391	+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
8662	8392	break;
8663	8393	}
8664		- case 18446744073709551258LLU: // 999999994Z'''''''''''''''
	8394	+ case 18446744073709551266LLU: // 999999994g'''''''''''''''
8665	8395	{
8666	8396	// variable list<resdest___> yres______ goes out of scope
8667	8397	// emitted destructur for type list<resdest___>
8668		- state.addr = 18446744073709551255LLU; // 999999994W'''''''''''''''
	8398	+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8669	8399	break;
8670	8400	}
8671		- case 18446744073709551255LLU: // 999999994W'''''''''''''''
	8401	+ case 18446744073709551263LLU: // 999999994d'''''''''''''''
8672	8402	{
8673	8403	if(!LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/)
8674	8404	{
8675		- state.addr = 18446744073709551256LLU; // 999999994X'''''''''''''''
	8405	+ state.addr = 18446744073709551264LLU; // 999999994e'''''''''''''''
8676	8406	break;
8677	8407	}
8678	8408	// temporary list-element

		@@ -8686,7 +8416,7 @@
8686	8416	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8687	8417	}
8688	8418	// ACCUMULATE ARGUMENTS - END
8689		- uint64_t return_to = 18446744073709551254LLU;
	8419	+ uint64_t return_to = 18446744073709551262LLU;
8690	8420	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8691	8421	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8692	8422	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8695,14 +8425,14 @@
8695	8425	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8696	8426	break;
8697	8427	}
8698		- case 18446744073709551254LLU: // 999999994V'''''''''''''''
	8428	+ case 18446744073709551262LLU: // 999999994c'''''''''''''''
8699	8429	{
8700	8430	// RELEASE temporary destructor-variable
8701	8431	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8702		- state.addr = 18446744073709551255LLU; // 999999994W'''''''''''''''
	8432	+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8703	8433	break;
8704	8434	}
8705		- case 18446744073709551256LLU: // 999999994X'''''''''''''''
	8435	+ case 18446744073709551264LLU: // 999999994e'''''''''''''''
8706	8436	{
8707	8437	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference yres______ at 4
8708	8438	{

		@@ -8717,10 +8447,10 @@
8717	8447	uint64_t arg = 0;
8718	8448	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
8719	8449	}
8720		- state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
	8450	+ state.addr = 18446744073709551261LLU; // 999999994b'''''''''''''''
8721	8451	break;
8722	8452	}
8723		- case 18446744073709551253LLU: // 999999994U'''''''''''''''
	8453	+ case 18446744073709551261LLU: // 999999994b'''''''''''''''
8724	8454	{
8725	8455	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8726	8456	{

		@@ -8727,7 +8457,7 @@
8727	8457	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8728	8458	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8729	8459	{
8730		- state.addr = 18446744073709551252LLU; // 999999994T'''''''''''''''
	8460	+ state.addr = 18446744073709551260LLU; // 999999994a'''''''''''''''
8731	8461	break;
8732	8462	}
8733	8463	}

		@@ -8747,7 +8477,7 @@
8747	8477	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8748	8478	}
8749	8479	// ACCUMULATE ARGUMENTS - END
8750		- uint64_t return_to = 18446744073709551248LLU;
	8480	+ uint64_t return_to = 18446744073709551256LLU;
8751	8481	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
8752	8482	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8753	8483	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8756,12 +8486,12 @@
8756	8486	state.addr = 296309897384864500LLU; // ParDefCopy
8757	8487	break;
8758	8488	}
8759		- case 18446744073709551248LLU: // 999999994P'''''''''''''''
	8489	+ case 18446744073709551256LLU: // 999999994X'''''''''''''''
8760	8490	{
8761		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551251LLU : 18446744073709551250LLU;
	8491	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551259LLU : 18446744073709551258LLU;
8762	8492	break;
8763	8493	}
8764		- case 18446744073709551251LLU: // 999999994S'''''''''''''''
	8494	+ case 18446744073709551259LLU: // 999999994$'''''''''''''''
8765	8495	{
8766	8496	{
8767	8497	fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");

		@@ -8774,35 +8504,35 @@
8774	8504	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8775	8505	}
8776	8506	// ACCUMULATE ARGUMENTS - END
8777		- uint64_t return_to = 18446744073709551247LLU;
	8507	+ uint64_t return_to = 18446744073709551255LLU;
8778	8508	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8779	8509	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8780	8510	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8781	8511	heap.data[0].elem1 = heap.data[0].elem0;
8782	8512	heap.data[0].elem0 = restore;
8783		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	8513	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8784	8514	break;
8785	8515	}
8786		- case 18446744073709551247LLU: // 999999994O'''''''''''''''
	8516	+ case 18446744073709551255LLU: // 999999994W'''''''''''''''
8787	8517	{
8788	8518	// parameter pardef____ new_______ goes out of scope
8789		- state.addr = 18446744073709551249LLU; // 999999994Q'''''''''''''''
	8519	+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
8790	8520	break;
8791	8521	}
8792		- case 18446744073709551250LLU: // 999999994R'''''''''''''''
	8522	+ case 18446744073709551258LLU: // 999999994Z'''''''''''''''
8793	8523	{
8794		- state.addr = 18446744073709551249LLU; // 999999994Q'''''''''''''''
	8524	+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
8795	8525	break;
8796	8526	}
8797		- case 18446744073709551249LLU: // 999999994Q'''''''''''''''
	8527	+ case 18446744073709551257LLU: // 999999994Y'''''''''''''''
8798	8528	{
8799	8529	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8800	8530	// parameter-reference pardef____ par1______ goes out of scope
8801	8531	// parameter-reference function__ y_________ goes out of scope
8802		- state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
	8532	+ state.addr = 18446744073709551261LLU; // 999999994b'''''''''''''''
8803	8533	break;
8804	8534	}
8805		- case 18446744073709551252LLU: // 999999994T'''''''''''''''
	8535	+ case 18446744073709551260LLU: // 999999994a'''''''''''''''
8806	8536	{
8807	8537	list_reverse(heap.data, &/ypars_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
8808	8538	{

		@@ -8813,10 +8543,10 @@
8813	8543	uint64_t arg = 0;
8814	8544	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
8815	8545	}
8816		- state.addr = 18446744073709551246LLU; // 999999994N'''''''''''''''
	8546	+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
8817	8547	break;
8818	8548	}
8819		- case 18446744073709551246LLU: // 999999994N'''''''''''''''
	8549	+ case 18446744073709551254LLU: // 999999994V'''''''''''''''
8820	8550	{
8821	8551	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8822	8552	{

		@@ -8823,16 +8553,16 @@
8823	8553	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8824	8554	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8825	8555	{
8826		- state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
	8556	+ state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
8827	8557	break;
8828	8558	}
8829	8559	}
8830	8560	/direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8831	8561	LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8832		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551244LLU : 18446744073709551243LLU;
	8562	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551252LLU : 18446744073709551251LLU;
8833	8563	break;
8834	8564	}
8835		- case 18446744073709551244LLU: // 999999994L'''''''''''''''
	8565	+ case 18446744073709551252LLU: // 999999994T'''''''''''''''
8836	8566	{
8837	8567	{
8838	8568	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/list*/, 11);

		@@ -8857,7 +8587,7 @@
8857	8587	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8858	8588	}
8859	8589	// ACCUMULATE ARGUMENTS - END
8860		- uint64_t return_to = 18446744073709551241LLU;
	8590	+ uint64_t return_to = 18446744073709551249LLU;
8861	8591	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
8862	8592	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8863	8593	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -8866,7 +8596,7 @@
8866	8596	state.addr = 589059743276730432LLU; // equpardef_
8867	8597	break;
8868	8598	}
8869		- case 18446744073709551241LLU: // 999999994I'''''''''''''''
	8599	+ case 18446744073709551249LLU: // 999999994Q'''''''''''''''
8870	8600	{
8871	8601
8872	8602	access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);

		@@ -8881,41 +8611,41 @@
8881	8611	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8882	8612	}
8883	8613	// ACCUMULATE ARGUMENTS - END
8884		- uint64_t return_to = 18446744073709551240LLU;
	8614	+ uint64_t return_to = 18446744073709551248LLU;
8885	8615	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8886	8616	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8887	8617	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8888	8618	heap.data[0].elem1 = heap.data[0].elem0;
8889	8619	heap.data[0].elem0 = restore;
8890		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	8620	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8891	8621	break;
8892	8622	}
8893		- case 18446744073709551240LLU: // 999999994H'''''''''''''''
	8623	+ case 18446744073709551248LLU: // 999999994P'''''''''''''''
8894	8624	{
8895	8625	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 7
8896		- state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
	8626	+ state.addr = 18446744073709551250LLU; // 999999994R'''''''''''''''
8897	8627	break;
8898	8628	}
8899		- case 18446744073709551243LLU: // 999999994K'''''''''''''''
	8629	+ case 18446744073709551251LLU: // 999999994S'''''''''''''''
8900	8630	{
8901	8631
8902	8632	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0;
8903		- state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
	8633	+ state.addr = 18446744073709551250LLU; // 999999994R'''''''''''''''
8904	8634	break;
8905	8635	}
8906		- case 18446744073709551242LLU: // 999999994J'''''''''''''''
	8636	+ case 18446744073709551250LLU: // 999999994R'''''''''''''''
8907	8637	{
8908	8638	// parameter-reference pardef____ par0______ goes out of scope
8909	8639	// parameter-reference function__ x_________ goes out of scope
8910		- state.addr = 18446744073709551246LLU; // 999999994N'''''''''''''''
	8640	+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
8911	8641	break;
8912	8642	}
8913		- case 18446744073709551245LLU: // 999999994M'''''''''''''''
	8643	+ case 18446744073709551253LLU: // 999999994U'''''''''''''''
8914	8644	{
8915		- state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551239LLU : 18446744073709551238LLU;
	8645	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551247LLU : 18446744073709551246LLU;
8916	8646	break;
8917	8647	}
8918		- case 18446744073709551239LLU: // 999999994G'''''''''''''''
	8648	+ case 18446744073709551247LLU: // 999999994O'''''''''''''''
8919	8649	{
8920	8650	{
8921	8651	uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/, 11);

		@@ -8931,38 +8661,38 @@
8931	8661	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8932	8662	}
8933	8663	// ACCUMULATE ARGUMENTS - END
8934		- uint64_t return_to = 18446744073709551236LLU;
	8664	+ uint64_t return_to = 18446744073709551244LLU;
8935	8665	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8936	8666	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8937	8667	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8938	8668	heap.data[0].elem1 = heap.data[0].elem0;
8939	8669	heap.data[0].elem0 = restore;
8940		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	8670	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8941	8671	break;
8942	8672	}
8943		- case 18446744073709551236LLU: // 999999994D'''''''''''''''
	8673	+ case 18446744073709551244LLU: // 999999994L'''''''''''''''
8944	8674	{
8945	8675	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 5
8946		- state.addr = 18446744073709551237LLU; // 999999994E'''''''''''''''
	8676	+ state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
8947	8677	break;
8948	8678	}
8949		- case 18446744073709551238LLU: // 999999994F'''''''''''''''
	8679	+ case 18446744073709551246LLU: // 999999994N'''''''''''''''
8950	8680	{
8951		- state.addr = 18446744073709551237LLU; // 999999994E'''''''''''''''
	8681	+ state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
8952	8682	break;
8953	8683	}
8954		- case 18446744073709551237LLU: // 999999994E'''''''''''''''
	8684	+ case 18446744073709551245LLU: // 999999994M'''''''''''''''
8955	8685	{
8956	8686	// variable list<pardef____> ypars_____ goes out of scope
8957	8687	// emitted destructur for type list<pardef____>
8958		- state.addr = 18446744073709551234LLU; // 999999994B'''''''''''''''
	8688	+ state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
8959	8689	break;
8960	8690	}
8961		- case 18446744073709551234LLU: // 999999994B'''''''''''''''
	8691	+ case 18446744073709551242LLU: // 999999994J'''''''''''''''
8962	8692	{
8963	8693	if(!LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/)
8964	8694	{
8965		- state.addr = 18446744073709551235LLU; // 999999994C'''''''''''''''
	8695	+ state.addr = 18446744073709551243LLU; // 999999994K'''''''''''''''
8966	8696	break;
8967	8697	}
8968	8698	// temporary list-element

		@@ -8976,23 +8706,23 @@
8976	8706	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8977	8707	}
8978	8708	// ACCUMULATE ARGUMENTS - END
8979		- uint64_t return_to = 18446744073709551233LLU;
	8709	+ uint64_t return_to = 18446744073709551241LLU;
8980	8710	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
8981	8711	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8982	8712	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8983	8713	heap.data[0].elem1 = heap.data[0].elem0;
8984	8714	heap.data[0].elem0 = restore;
8985		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	8715	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8986	8716	break;
8987	8717	}
8988		- case 18446744073709551233LLU: // 999999994A'''''''''''''''
	8718	+ case 18446744073709551241LLU: // 999999994I'''''''''''''''
8989	8719	{
8990	8720	// RELEASE temporary destructor-variable
8991	8721	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
8992		- state.addr = 18446744073709551234LLU; // 999999994B'''''''''''''''
	8722	+ state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
8993	8723	break;
8994	8724	}
8995		- case 18446744073709551235LLU: // 999999994C'''''''''''''''
	8725	+ case 18446744073709551243LLU: // 999999994K'''''''''''''''
8996	8726	{
8997	8727	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ypars_____ at 4
8998	8728	{

		@@ -9059,7 +8789,7 @@
9059	8789	}
9060	8790	break;
9061	8791	}
9062		- case 18446744073709551232LLU: // 999999994_'''''''''''''''
	8792	+ case 18446744073709551240LLU: // 999999994H'''''''''''''''
9063	8793	{
9064	8794	{
9065	8795	uint64_t arg = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -9066,14 +8796,14 @@
9066	8796	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
9067	8797	}
9068	8798	// emitted destructur for type list<elemdef___>
9069		- state.addr = 18446744073709551230LLU; // 9999999938'''''''''''''''
	8799	+ state.addr = 18446744073709551238LLU; // 999999994F'''''''''''''''
9070	8800	break;
9071	8801	}
9072		- case 18446744073709551230LLU: // 9999999938'''''''''''''''
	8802	+ case 18446744073709551238LLU: // 999999994F'''''''''''''''
9073	8803	{
9074	8804	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
9075	8805	{
9076		- state.addr = 18446744073709551231LLU; // 9999999939'''''''''''''''
	8806	+ state.addr = 18446744073709551239LLU; // 999999994G'''''''''''''''
9077	8807	break;
9078	8808	}
9079	8809	// temporary list-element

		@@ -9087,23 +8817,23 @@
9087	8817	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9088	8818	}
9089	8819	// ACCUMULATE ARGUMENTS - END
9090		- uint64_t return_to = 18446744073709551229LLU;
	8820	+ uint64_t return_to = 18446744073709551237LLU;
9091	8821	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9092	8822	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9093	8823	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9094	8824	heap.data[0].elem1 = heap.data[0].elem0;
9095	8825	heap.data[0].elem0 = restore;
9096		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	8826	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
9097	8827	break;
9098	8828	}
9099		- case 18446744073709551229LLU: // 9999999937'''''''''''''''
	8829	+ case 18446744073709551237LLU: // 999999994E'''''''''''''''
9100	8830	{
9101	8831	// RELEASE temporary destructor-variable
9102	8832	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
9103		- state.addr = 18446744073709551230LLU; // 9999999938'''''''''''''''
	8833	+ state.addr = 18446744073709551238LLU; // 999999994F'''''''''''''''
9104	8834	break;
9105	8835	}
9106		- case 18446744073709551231LLU: // 9999999939'''''''''''''''
	8836	+ case 18446744073709551239LLU: // 999999994G'''''''''''''''
9107	8837	{
9108	8838	// RELEASE temporary destructor-variable
9109	8839	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -9182,10 +8912,10 @@
9182	8912	uint64_t arg = 0;
9183	8913	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
9184	8914	}
9185		- state.addr = 18446744073709551227LLU; // 9999999935'''''''''''''''
	8915	+ state.addr = 18446744073709551235LLU; // 999999994C'''''''''''''''
9186	8916	break;
9187	8917	}
9188		- case 18446744073709551227LLU: // 9999999935'''''''''''''''
	8918	+ case 18446744073709551235LLU: // 999999994C'''''''''''''''
9189	8919	{
9190	8920	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
9191	8921	{

		@@ -9192,7 +8922,7 @@
9192	8922	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
9193	8923	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
9194	8924	{
9195		- state.addr = 18446744073709551226LLU; // 9999999934'''''''''''''''
	8925	+ state.addr = 18446744073709551234LLU; // 999999994B'''''''''''''''
9196	8926	break;
9197	8927	}
9198	8928	}

		@@ -9212,7 +8942,7 @@
9212	8942	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9213	8943	}
9214	8944	// ACCUMULATE ARGUMENTS - END
9215		- uint64_t return_to = 18446744073709551222LLU;
	8945	+ uint64_t return_to = 18446744073709551230LLU;
9216	8946	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9217	8947	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9218	8948	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9221,12 +8951,12 @@
9221	8951	state.addr = 101193007747052544LLU; // ElemDefCP_
9222	8952	break;
9223	8953	}
9224		- case 18446744073709551222LLU: // 9999999930'''''''''''''''
	8954	+ case 18446744073709551230LLU: // 9999999938'''''''''''''''
9225	8955	{
9226		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551225LLU : 18446744073709551224LLU;
	8956	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551233LLU : 18446744073709551232LLU;
9227	8957	break;
9228	8958	}
9229		- case 18446744073709551225LLU: // 9999999933'''''''''''''''
	8959	+ case 18446744073709551233LLU: // 999999994A'''''''''''''''
9230	8960	{
9231	8961	{
9232	8962	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap");

		@@ -9239,35 +8969,35 @@
9239	8969	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9240	8970	}
9241	8971	// ACCUMULATE ARGUMENTS - END
9242		- uint64_t return_to = 18446744073709551221LLU;
	8972	+ uint64_t return_to = 18446744073709551229LLU;
9243	8973	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9244	8974	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9245	8975	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9246	8976	heap.data[0].elem1 = heap.data[0].elem0;
9247	8977	heap.data[0].elem0 = restore;
9248		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	8978	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
9249	8979	break;
9250	8980	}
9251		- case 18446744073709551221LLU: // 999999993z'''''''''''''''
	8981	+ case 18446744073709551229LLU: // 9999999937'''''''''''''''
9252	8982	{
9253	8983	// parameter elemdef___ dstpar____ goes out of scope
9254		- state.addr = 18446744073709551223LLU; // 9999999931'''''''''''''''
	8984	+ state.addr = 18446744073709551231LLU; // 9999999939'''''''''''''''
9255	8985	break;
9256	8986	}
9257		- case 18446744073709551224LLU: // 9999999932'''''''''''''''
	8987	+ case 18446744073709551232LLU: // 999999994_'''''''''''''''
9258	8988	{
9259		- state.addr = 18446744073709551223LLU; // 9999999931'''''''''''''''
	8989	+ state.addr = 18446744073709551231LLU; // 9999999939'''''''''''''''
9260	8990	break;
9261	8991	}
9262		- case 18446744073709551223LLU: // 9999999931'''''''''''''''
	8992	+ case 18446744073709551231LLU: // 9999999939'''''''''''''''
9263	8993	{
9264	8994	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
9265	8995	// parameter-reference elemdef___ srcpar____ goes out of scope
9266	8996	// parameter-reference list<elemdef___> srcpars___ goes out of scope
9267		- state.addr = 18446744073709551227LLU; // 9999999935'''''''''''''''
	8997	+ state.addr = 18446744073709551235LLU; // 999999994C'''''''''''''''
9268	8998	break;
9269	8999	}
9270		- case 18446744073709551226LLU: // 9999999934'''''''''''''''
	9000	+ case 18446744073709551234LLU: // 999999994B'''''''''''''''
9271	9001	{
9272	9002	// ACCUMULATE ARGUMENTS - BEGIN
9273	9003	{

		@@ -9283,7 +9013,7 @@
9283	9013	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9284	9014	}
9285	9015	// ACCUMULATE ARGUMENTS - END
9286		- uint64_t return_to = 18446744073709551220LLU;
	9016	+ uint64_t return_to = 18446744073709551228LLU;
9287	9017	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
9288	9018	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9289	9019	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9292,7 +9022,7 @@
9292	9022	state.addr = 890787243071635456LLU; // variant___
9293	9023	break;
9294	9024	}
9295		- case 18446744073709551220LLU: // 999999993y'''''''''''''''
	9025	+ case 18446744073709551228LLU: // 9999999936'''''''''''''''
9296	9026	{
9297	9027	// variable list<elemdef___> dstpars___ goes out of scope
9298	9028	// (uninitialized -> no destructor-call)

		@@ -9342,10 +9072,10 @@
9342	9072	uint64_t arg = 0;
9343	9073	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
9344	9074	}
9345		- state.addr = 18446744073709551218LLU; // 999999993w'''''''''''''''
	9075	+ state.addr = 18446744073709551226LLU; // 9999999934'''''''''''''''
9346	9076	break;
9347	9077	}
9348		- case 18446744073709551218LLU: // 999999993w'''''''''''''''
	9078	+ case 18446744073709551226LLU: // 9999999934'''''''''''''''
9349	9079	{
9350	9080	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
9351	9081	{

		@@ -9352,7 +9082,7 @@
9352	9082	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
9353	9083	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
9354	9084	{
9355		- state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
	9085	+ state.addr = 18446744073709551225LLU; // 9999999933'''''''''''''''
9356	9086	break;
9357	9087	}
9358	9088	}

		@@ -9372,7 +9102,7 @@
9372	9102	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9373	9103	}
9374	9104	// ACCUMULATE ARGUMENTS - END
9375		- uint64_t return_to = 18446744073709551213LLU;
	9105	+ uint64_t return_to = 18446744073709551221LLU;
9376	9106	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9377	9107	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9378	9108	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9381,12 +9111,12 @@
9381	9111	state.addr = 101193007747052544LLU; // ElemDefCP_
9382	9112	break;
9383	9113	}
9384		- case 18446744073709551213LLU: // 999999993r'''''''''''''''
	9114	+ case 18446744073709551221LLU: // 999999993z'''''''''''''''
9385	9115	{
9386		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551216LLU : 18446744073709551215LLU;
	9116	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551224LLU : 18446744073709551223LLU;
9387	9117	break;
9388	9118	}
9389		- case 18446744073709551216LLU: // 999999993u'''''''''''''''
	9119	+ case 18446744073709551224LLU: // 9999999932'''''''''''''''
9390	9120	{
9391	9121	{
9392	9122	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap");

		@@ -9399,35 +9129,35 @@
9399	9129	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9400	9130	}
9401	9131	// ACCUMULATE ARGUMENTS - END
9402		- uint64_t return_to = 18446744073709551212LLU;
	9132	+ uint64_t return_to = 18446744073709551220LLU;
9403	9133	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9404	9134	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9405	9135	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9406	9136	heap.data[0].elem1 = heap.data[0].elem0;
9407	9137	heap.data[0].elem0 = restore;
9408		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	9138	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
9409	9139	break;
9410	9140	}
9411		- case 18446744073709551212LLU: // 999999993q'''''''''''''''
	9141	+ case 18446744073709551220LLU: // 999999993y'''''''''''''''
9412	9142	{
9413	9143	// parameter elemdef___ dstpar____ goes out of scope
9414		- state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
	9144	+ state.addr = 18446744073709551222LLU; // 9999999930'''''''''''''''
9415	9145	break;
9416	9146	}
9417		- case 18446744073709551215LLU: // 999999993t'''''''''''''''
	9147	+ case 18446744073709551223LLU: // 9999999931'''''''''''''''
9418	9148	{
9419		- state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
	9149	+ state.addr = 18446744073709551222LLU; // 9999999930'''''''''''''''
9420	9150	break;
9421	9151	}
9422		- case 18446744073709551214LLU: // 999999993s'''''''''''''''
	9152	+ case 18446744073709551222LLU: // 9999999930'''''''''''''''
9423	9153	{
9424	9154	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
9425	9155	// parameter-reference elemdef___ srcpar____ goes out of scope
9426	9156	// parameter-reference list<elemdef___> srcpars___ goes out of scope
9427		- state.addr = 18446744073709551218LLU; // 999999993w'''''''''''''''
	9157	+ state.addr = 18446744073709551226LLU; // 9999999934'''''''''''''''
9428	9158	break;
9429	9159	}
9430		- case 18446744073709551217LLU: // 999999993v'''''''''''''''
	9160	+ case 18446744073709551225LLU: // 9999999933'''''''''''''''
9431	9161	{
9432	9162	list_reverse(heap.data, &/dstpars___/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
9433	9163	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -9444,7 +9174,7 @@
9444	9174	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9445	9175	}
9446	9176	// ACCUMULATE ARGUMENTS - END
9447		- uint64_t return_to = 18446744073709551211LLU;
	9177	+ uint64_t return_to = 18446744073709551219LLU;
9448	9178	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
9449	9179	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9450	9180	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9453,7 +9183,7 @@
9453	9183	state.addr = 890787243071635456LLU; // variant___
9454	9184	break;
9455	9185	}
9456		- case 18446744073709551211LLU: // 999999993p'''''''''''''''
	9186	+ case 18446744073709551219LLU: // 999999993x'''''''''''''''
9457	9187	{
9458	9188	// variable list<elemdef___> dstpars___ goes out of scope
9459	9189	// (uninitialized -> no destructor-call)

		@@ -9490,10 +9220,10 @@
9490	9220	uint64_t arg = 0;
9491	9221	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
9492	9222	}
9493		- state.addr = 18446744073709551210LLU; // 999999993o'''''''''''''''
	9223	+ state.addr = 18446744073709551218LLU; // 999999993w'''''''''''''''
9494	9224	break;
9495	9225	}
9496		- case 18446744073709551210LLU: // 999999993o'''''''''''''''
	9226	+ case 18446744073709551218LLU: // 999999993w'''''''''''''''
9497	9227	{
9498	9228	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
9499	9229	{

		@@ -9500,7 +9230,7 @@
9500	9230	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
9501	9231	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
9502	9232	{
9503		- state.addr = 18446744073709551209LLU; // 999999993n'''''''''''''''
	9233	+ state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
9504	9234	break;
9505	9235	}
9506	9236	}

		@@ -9520,7 +9250,7 @@
9520	9250	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9521	9251	}
9522	9252	// ACCUMULATE ARGUMENTS - END
9523		- uint64_t return_to = 18446744073709551205LLU;
	9253	+ uint64_t return_to = 18446744073709551213LLU;
9524	9254	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9525	9255	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9526	9256	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9529,12 +9259,12 @@
9529	9259	state.addr = 66057858067013632LLU; // CopyVarR__
9530	9260	break;
9531	9261	}
9532		- case 18446744073709551205LLU: // 999999993j'''''''''''''''
	9262	+ case 18446744073709551213LLU: // 999999993r'''''''''''''''
9533	9263	{
9534		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551208LLU : 18446744073709551207LLU;
	9264	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551216LLU : 18446744073709551215LLU;
9535	9265	break;
9536	9266	}
9537		- case 18446744073709551208LLU: // 999999993m'''''''''''''''
	9267	+ case 18446744073709551216LLU: // 999999993u'''''''''''''''
9538	9268	{
9539	9269	{
9540	9270	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvars - recompile compiler with more dynamic heap");

		@@ -9547,35 +9277,35 @@
9547	9277	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9548	9278	}
9549	9279	// ACCUMULATE ARGUMENTS - END
9550		- uint64_t return_to = 18446744073709551204LLU;
	9280	+ uint64_t return_to = 18446744073709551212LLU;
9551	9281	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9552	9282	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9553	9283	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9554	9284	heap.data[0].elem1 = heap.data[0].elem0;
9555	9285	heap.data[0].elem0 = restore;
9556		- state.addr = 18446744073709551232LLU; // 999999994_'''''''''''''''
	9286	+ state.addr = 18446744073709551240LLU; // 999999994H'''''''''''''''
9557	9287	break;
9558	9288	}
9559		- case 18446744073709551204LLU: // 999999993i'''''''''''''''
	9289	+ case 18446744073709551212LLU: // 999999993q'''''''''''''''
9560	9290	{
9561	9291	// parameter variant___ dst_______ goes out of scope
9562		- state.addr = 18446744073709551206LLU; // 999999993k'''''''''''''''
	9292	+ state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
9563	9293	break;
9564	9294	}
9565		- case 18446744073709551207LLU: // 999999993l'''''''''''''''
	9295	+ case 18446744073709551215LLU: // 999999993t'''''''''''''''
9566	9296	{
9567		- state.addr = 18446744073709551206LLU; // 999999993k'''''''''''''''
	9297	+ state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
9568	9298	break;
9569	9299	}
9570		- case 18446744073709551206LLU: // 999999993k'''''''''''''''
	9300	+ case 18446744073709551214LLU: // 999999993s'''''''''''''''
9571	9301	{
9572	9302	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
9573	9303	// parameter-reference variant___ src_______ goes out of scope
9574	9304	// parameter-reference list<variant___> srcs______ goes out of scope
9575		- state.addr = 18446744073709551210LLU; // 999999993o'''''''''''''''
	9305	+ state.addr = 18446744073709551218LLU; // 999999993w'''''''''''''''
9576	9306	break;
9577	9307	}
9578		- case 18446744073709551209LLU: // 999999993n'''''''''''''''
	9308	+ case 18446744073709551217LLU: // 999999993v'''''''''''''''
9579	9309	{
9580	9310	swap(&LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
9581	9311	// variable list<variant___> dsts______ goes out of scope

		@@ -9592,7 +9322,7 @@
9592	9322	}
9593	9323	break;
9594	9324	}
9595		- case 18446744073709551202LLU: // 999999993g'''''''''''''''
	9325	+ case 18446744073709551210LLU: // 999999993o'''''''''''''''
9596	9326	{
9597	9327	// destructor for variant tkunion___
9598	9328	{

		@@ -9600,14 +9330,14 @@
9600	9330	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
9601	9331	}
9602	9332	// emitted destructur for type list<variant___>
9603		- state.addr = 18446744073709551199LLU; // 999999993d'''''''''''''''
	9333	+ state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
9604	9334	break;
9605	9335	}
9606		- case 18446744073709551199LLU: // 999999993d'''''''''''''''
	9336	+ case 18446744073709551207LLU: // 999999993l'''''''''''''''
9607	9337	{
9608	9338	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
9609	9339	{
9610		- state.addr = 18446744073709551200LLU; // 999999993e'''''''''''''''
	9340	+ state.addr = 18446744073709551208LLU; // 999999993m'''''''''''''''
9611	9341	break;
9612	9342	}
9613	9343	// temporary list-element

		@@ -9621,23 +9351,23 @@
9621	9351	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9622	9352	}
9623	9353	// ACCUMULATE ARGUMENTS - END
9624		- uint64_t return_to = 18446744073709551198LLU;
	9354	+ uint64_t return_to = 18446744073709551206LLU;
9625	9355	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9626	9356	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9627	9357	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9628	9358	heap.data[0].elem1 = heap.data[0].elem0;
9629	9359	heap.data[0].elem0 = restore;
9630		- state.addr = 18446744073709551232LLU; // 999999994_'''''''''''''''
	9360	+ state.addr = 18446744073709551240LLU; // 999999994H'''''''''''''''
9631	9361	break;
9632	9362	}
9633		- case 18446744073709551198LLU: // 999999993c'''''''''''''''
	9363	+ case 18446744073709551206LLU: // 999999993k'''''''''''''''
9634	9364	{
9635	9365	// RELEASE temporary destructor-variable
9636	9366	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
9637		- state.addr = 18446744073709551199LLU; // 999999993d'''''''''''''''
	9367	+ state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
9638	9368	break;
9639	9369	}
9640		- case 18446744073709551200LLU: // 999999993e'''''''''''''''
	9370	+ case 18446744073709551208LLU: // 999999993m'''''''''''''''
9641	9371	{
9642	9372	// RELEASE temporary destructor-variable
9643	9373	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -9651,7 +9381,7 @@
9651	9381	}
9652	9382	break;
9653	9383	}
9654		- case 18446744073709551201LLU: // 999999993f'''''''''''''''
	9384	+ case 18446744073709551209LLU: // 999999993n'''''''''''''''
9655	9385	{
9656	9386	// destructor for variant tkstruct__
9657	9387	{

		@@ -9659,14 +9389,14 @@
9659	9389	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
9660	9390	}
9661	9391	// emitted destructur for type list<elemdef___>
9662		- state.addr = 18446744073709551196LLU; // 999999993a'''''''''''''''
	9392	+ state.addr = 18446744073709551204LLU; // 999999993i'''''''''''''''
9663	9393	break;
9664	9394	}
9665		- case 18446744073709551196LLU: // 999999993a'''''''''''''''
	9395	+ case 18446744073709551204LLU: // 999999993i'''''''''''''''
9666	9396	{
9667	9397	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
9668	9398	{
9669		- state.addr = 18446744073709551197LLU; // 999999993b'''''''''''''''
	9399	+ state.addr = 18446744073709551205LLU; // 999999993j'''''''''''''''
9670	9400	break;
9671	9401	}
9672	9402	// temporary list-element

		@@ -9680,23 +9410,23 @@
9680	9410	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9681	9411	}
9682	9412	// ACCUMULATE ARGUMENTS - END
9683		- uint64_t return_to = 18446744073709551195LLU;
	9413	+ uint64_t return_to = 18446744073709551203LLU;
9684	9414	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9685	9415	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9686	9416	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9687	9417	heap.data[0].elem1 = heap.data[0].elem0;
9688	9418	heap.data[0].elem0 = restore;
9689		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	9419	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
9690	9420	break;
9691	9421	}
9692		- case 18446744073709551195LLU: // 999999993$'''''''''''''''
	9422	+ case 18446744073709551203LLU: // 999999993h'''''''''''''''
9693	9423	{
9694	9424	// RELEASE temporary destructor-variable
9695	9425	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
9696		- state.addr = 18446744073709551196LLU; // 999999993a'''''''''''''''
	9426	+ state.addr = 18446744073709551204LLU; // 999999993i'''''''''''''''
9697	9427	break;
9698	9428	}
9699		- case 18446744073709551197LLU: // 999999993b'''''''''''''''
	9429	+ case 18446744073709551205LLU: // 999999993j'''''''''''''''
9700	9430	{
9701	9431	// RELEASE temporary destructor-variable
9702	9432	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -9710,11 +9440,11 @@
9710	9440	}
9711	9441	break;
9712	9442	}
9713		- case 18446744073709551203LLU: // 999999993h'''''''''''''''
	9443	+ case 18446744073709551211LLU: // 999999993p'''''''''''''''
9714	9444	{
9715	9445	struct pair type_data = unpair(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
9716	9446	access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
9717		- state.addr = 18446744073709551201LLU + type_data.elem0;
	9447	+ state.addr = 18446744073709551209LLU + type_data.elem0;
9718	9448	break;
9719	9449	}
9720	9450	case 857586742161833984LLU: // tkunion___

		@@ -9777,7 +9507,7 @@
9777	9507	{
9778	9508	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/tkstruct__/)
9779	9509	{
9780		- state.addr = 18446744073709551194LLU; // 999999993Z'''''''''''''''
	9510	+ state.addr = 18446744073709551202LLU; // 999999993g'''''''''''''''
9781	9511	break;
9782	9512	}
9783	9513	{

		@@ -9800,10 +9530,10 @@
9800	9530	uint64_t arg = 0;
9801	9531	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
9802	9532	}
9803		- state.addr = 18446744073709551193LLU; // 999999993Y'''''''''''''''
	9533	+ state.addr = 18446744073709551201LLU; // 999999993f'''''''''''''''
9804	9534	break;
9805	9535	}
9806		- case 18446744073709551193LLU: // 999999993Y'''''''''''''''
	9536	+ case 18446744073709551201LLU: // 999999993f'''''''''''''''
9807	9537	{
9808	9538	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
9809	9539	{

		@@ -9810,7 +9540,7 @@
9810	9540	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
9811	9541	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
9812	9542	{
9813		- state.addr = 18446744073709551192LLU; // 999999993X'''''''''''''''
	9543	+ state.addr = 18446744073709551200LLU; // 999999993e'''''''''''''''
9814	9544	break;
9815	9545	}
9816	9546	}

		@@ -9843,7 +9573,7 @@
9843	9573	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9844	9574	}
9845	9575	// ACCUMULATE ARGUMENTS - END
9846		- uint64_t return_to = 18446744073709551187LLU;
	9576	+ uint64_t return_to = 18446744073709551195LLU;
9847	9577	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9848	9578	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9849	9579	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9852,7 +9582,7 @@
9852	9582	state.addr = 552446646280519680LLU; // copyu64___
9853	9583	break;
9854	9584	}
9855		- case 18446744073709551187LLU: // 999999993S'''''''''''''''
	9585	+ case 18446744073709551195LLU: // 999999993$'''''''''''''''
9856	9586	{
9857	9587	{
9858	9588	uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 10*/;

		@@ -9881,7 +9611,7 @@
9881	9611	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9882	9612	}
9883	9613	// ACCUMULATE ARGUMENTS - END
9884		- uint64_t return_to = 18446744073709551186LLU;
	9614	+ uint64_t return_to = 18446744073709551194LLU;
9885	9615	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9886	9616	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9887	9617	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9890,7 +9620,7 @@
9890	9620	state.addr = 367395560426147840LLU; // TYPECOPY__
9891	9621	break;
9892	9622	}
9893		- case 18446744073709551186LLU: // 999999993R'''''''''''''''
	9623	+ case 18446744073709551194LLU: // 999999993Z'''''''''''''''
9894	9624	{
9895	9625	{
9896	9626	uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 10*/;

		@@ -9902,7 +9632,7 @@
9902	9632	}
9903	9633	}
9904	9634	// ACCUMULATE ARGUMENTS - END
9905		- uint64_t return_to = 18446744073709551188LLU;
	9635	+ uint64_t return_to = 18446744073709551196LLU;
9906	9636	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
9907	9637	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9908	9638	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9911,12 +9641,12 @@
9911	9641	state.addr = 587581796494082048LLU; // elemdef___
9912	9642	break;
9913	9643	}
9914		- case 18446744073709551188LLU: // 999999993T'''''''''''''''
	9644	+ case 18446744073709551196LLU: // 999999993a'''''''''''''''
9915	9645	{
9916		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 7) ? 18446744073709551191LLU : 18446744073709551190LLU;
	9646	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 7) ? 18446744073709551199LLU : 18446744073709551198LLU;
9917	9647	break;
9918	9648	}
9919		- case 18446744073709551191LLU: // 999999993W'''''''''''''''
	9649	+ case 18446744073709551199LLU: // 999999993d'''''''''''''''
9920	9650	{
9921	9651	{
9922	9652	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap");

		@@ -9929,35 +9659,35 @@
9929	9659	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9930	9660	}
9931	9661	// ACCUMULATE ARGUMENTS - END
9932		- uint64_t return_to = 18446744073709551185LLU;
	9662	+ uint64_t return_to = 18446744073709551193LLU;
9933	9663	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
9934	9664	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9935	9665	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9936	9666	heap.data[0].elem1 = heap.data[0].elem0;
9937	9667	heap.data[0].elem0 = restore;
9938		- state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
	9668	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
9939	9669	break;
9940	9670	}
9941		- case 18446744073709551185LLU: // 999999993Q'''''''''''''''
	9671	+ case 18446744073709551193LLU: // 999999993Y'''''''''''''''
9942	9672	{
9943	9673	// parameter elemdef___ DEFPAR____ goes out of scope
9944		- state.addr = 18446744073709551189LLU; // 999999993U'''''''''''''''
	9674	+ state.addr = 18446744073709551197LLU; // 999999993b'''''''''''''''
9945	9675	break;
9946	9676	}
9947		- case 18446744073709551190LLU: // 999999993V'''''''''''''''
	9677	+ case 18446744073709551198LLU: // 999999993c'''''''''''''''
9948	9678	{
9949		- state.addr = 18446744073709551189LLU; // 999999993U'''''''''''''''
	9679	+ state.addr = 18446744073709551197LLU; // 999999993b'''''''''''''''
9950	9680	break;
9951	9681	}
9952		- case 18446744073709551189LLU: // 999999993U'''''''''''''''
	9682	+ case 18446744073709551197LLU: // 999999993b'''''''''''''''
9953	9683	{
9954	9684	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
9955	9685	// parameter-reference elemdef___ defpar____ goes out of scope
9956	9686	// parameter-reference list<elemdef___> defpars___ goes out of scope
9957		- state.addr = 18446744073709551193LLU; // 999999993Y'''''''''''''''
	9687	+ state.addr = 18446744073709551201LLU; // 999999993f'''''''''''''''
9958	9688	break;
9959	9689	}
9960		- case 18446744073709551192LLU: // 999999993X'''''''''''''''
	9690	+ case 18446744073709551200LLU: // 999999993e'''''''''''''''
9961	9691	{
9962	9692	list_reverse(heap.data, &/DEFPARS___/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));
9963	9693	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -9970,7 +9700,7 @@
9970	9700	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9971	9701	}
9972	9702	// ACCUMULATE ARGUMENTS - END
9973		- uint64_t return_to = 18446744073709551184LLU;
	9703	+ uint64_t return_to = 18446744073709551192LLU;
9974	9704	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
9975	9705	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9976	9706	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -9979,7 +9709,7 @@
9979	9709	state.addr = 857578368147320832LLU; // tkstruct__
9980	9710	break;
9981	9711	}
9982		- case 18446744073709551184LLU: // 999999993P'''''''''''''''
	9712	+ case 18446744073709551192LLU: // 999999993X'''''''''''''''
9983	9713	{
9984	9714	// variable list<elemdef___> DEFPARS___ goes out of scope
9985	9715	// (uninitialized -> no destructor-call)

		@@ -9999,11 +9729,11 @@
9999	9729	}
10000	9730	break;
10001	9731	}
10002		- case 18446744073709551194LLU: // 999999993Z'''''''''''''''
	9732	+ case 18446744073709551202LLU: // 999999993g'''''''''''''''
10003	9733	{
10004	9734	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/tkunion___/)
10005	9735	{
10006		- state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
	9736	+ state.addr = 18446744073709551191LLU; // 999999993W'''''''''''''''
10007	9737	break;
10008	9738	}
10009	9739	{

		@@ -10026,10 +9756,10 @@
10026	9756	uint64_t arg = 0;
10027	9757	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
10028	9758	}
10029		- state.addr = 18446744073709551182LLU; // 999999993N'''''''''''''''
	9759	+ state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
10030	9760	break;
10031	9761	}
10032		- case 18446744073709551182LLU: // 999999993N'''''''''''''''
	9762	+ case 18446744073709551190LLU: // 999999993V'''''''''''''''
10033	9763	{
10034	9764	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
10035	9765	{

		@@ -10036,7 +9766,7 @@
10036	9766	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
10037	9767	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
10038	9768	{
10039		- state.addr = 18446744073709551181LLU; // 999999993M'''''''''''''''
	9769	+ state.addr = 18446744073709551189LLU; // 999999993U'''''''''''''''
10040	9770	break;
10041	9771	}
10042	9772	}

		@@ -10056,7 +9786,7 @@
10056	9786	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10057	9787	}
10058	9788	// ACCUMULATE ARGUMENTS - END
10059		- uint64_t return_to = 18446744073709551177LLU;
	9789	+ uint64_t return_to = 18446744073709551185LLU;
10060	9790	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10061	9791	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10062	9792	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10065,12 +9795,12 @@
10065	9795	state.addr = 66057858066939904LLU; // CopyVar___
10066	9796	break;
10067	9797	}
10068		- case 18446744073709551177LLU: // 999999993I'''''''''''''''
	9798	+ case 18446744073709551185LLU: // 999999993Q'''''''''''''''
10069	9799	{
10070		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551180LLU : 18446744073709551179LLU;
	9800	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551188LLU : 18446744073709551187LLU;
10071	9801	break;
10072	9802	}
10073		- case 18446744073709551180LLU: // 999999993L'''''''''''''''
	9803	+ case 18446744073709551188LLU: // 999999993T'''''''''''''''
10074	9804	{
10075	9805	{
10076	9806	fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap");

		@@ -10083,35 +9813,35 @@
10083	9813	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10084	9814	}
10085	9815	// ACCUMULATE ARGUMENTS - END
10086		- uint64_t return_to = 18446744073709551176LLU;
	9816	+ uint64_t return_to = 18446744073709551184LLU;
10087	9817	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10088	9818	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10089	9819	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10090	9820	heap.data[0].elem1 = heap.data[0].elem0;
10091	9821	heap.data[0].elem0 = restore;
10092		- state.addr = 18446744073709551232LLU; // 999999994_'''''''''''''''
	9822	+ state.addr = 18446744073709551240LLU; // 999999994H'''''''''''''''
10093	9823	break;
10094	9824	}
10095		- case 18446744073709551176LLU: // 999999993H'''''''''''''''
	9825	+ case 18446744073709551184LLU: // 999999993P'''''''''''''''
10096	9826	{
10097	9827	// parameter variant___ tmp_______ goes out of scope
10098		- state.addr = 18446744073709551178LLU; // 999999993J'''''''''''''''
	9828	+ state.addr = 18446744073709551186LLU; // 999999993R'''''''''''''''
10099	9829	break;
10100	9830	}
10101		- case 18446744073709551179LLU: // 999999993K'''''''''''''''
	9831	+ case 18446744073709551187LLU: // 999999993S'''''''''''''''
10102	9832	{
10103		- state.addr = 18446744073709551178LLU; // 999999993J'''''''''''''''
	9833	+ state.addr = 18446744073709551186LLU; // 999999993R'''''''''''''''
10104	9834	break;
10105	9835	}
10106		- case 18446744073709551178LLU: // 999999993J'''''''''''''''
	9836	+ case 18446744073709551186LLU: // 999999993R'''''''''''''''
10107	9837	{
10108	9838	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
10109	9839	// parameter-reference variant___ constr____ goes out of scope
10110	9840	// parameter-reference list<variant___> constrs___ goes out of scope
10111		- state.addr = 18446744073709551182LLU; // 999999993N'''''''''''''''
	9841	+ state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
10112	9842	break;
10113	9843	}
10114		- case 18446744073709551181LLU: // 999999993M'''''''''''''''
	9844	+ case 18446744073709551189LLU: // 999999993U'''''''''''''''
10115	9845	{
10116	9846	list_reverse(heap.data, &/CONSTRS___/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));
10117	9847	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -10124,7 +9854,7 @@
10124	9854	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10125	9855	}
10126	9856	// ACCUMULATE ARGUMENTS - END
10127		- uint64_t return_to = 18446744073709551175LLU;
	9857	+ uint64_t return_to = 18446744073709551183LLU;
10128	9858	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10129	9859	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10130	9860	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10133,7 +9863,7 @@
10133	9863	state.addr = 857586742161833984LLU; // tkunion___
10134	9864	break;
10135	9865	}
10136		- case 18446744073709551175LLU: // 999999993G'''''''''''''''
	9866	+ case 18446744073709551183LLU: // 999999993O'''''''''''''''
10137	9867	{
10138	9868	// variable list<variant___> CONSTRS___ goes out of scope
10139	9869	// (uninitialized -> no destructor-call)

		@@ -10153,7 +9883,7 @@
10153	9883	}
10154	9884	break;
10155	9885	}
10156		- case 18446744073709551183LLU: // 999999993O'''''''''''''''
	9886	+ case 18446744073709551191LLU: // 999999993W'''''''''''''''
10157	9887	{
10158	9888	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CopyTK____\n");
10159	9889	exit(-1);

		@@ -10163,7 +9893,7 @@
10163	9893	{
10164	9894	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/tkstruct__/)
10165	9895	{
10166		- state.addr = 18446744073709551174LLU; // 999999993F'''''''''''''''
	9896	+ state.addr = 18446744073709551182LLU; // 999999993N'''''''''''''''
10167	9897	break;
10168	9898	}
10169	9899	{

		@@ -10183,11 +9913,11 @@
10183	9913	}
10184	9914	break;
10185	9915	}
10186		- case 18446744073709551174LLU: // 999999993F'''''''''''''''
	9916	+ case 18446744073709551182LLU: // 999999993N'''''''''''''''
10187	9917	{
10188	9918	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/tkunion___/)
10189	9919	{
10190		- state.addr = 18446744073709551173LLU; // 999999993E'''''''''''''''
	9920	+ state.addr = 18446744073709551181LLU; // 999999993M'''''''''''''''
10191	9921	break;
10192	9922	}
10193	9923	{

		@@ -10207,13 +9937,13 @@
10207	9937	}
10208	9938	break;
10209	9939	}
10210		- case 18446744073709551173LLU: // 999999993E'''''''''''''''
	9940	+ case 18446744073709551181LLU: // 999999993M'''''''''''''''
10211	9941	{
10212	9942	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttyk_\n");
10213	9943	exit(-1);
10214	9944	break;
10215	9945	}
10216		- case 18446744073709551172LLU: // 999999993D'''''''''''''''
	9946	+ case 18446744073709551180LLU: // 999999993L'''''''''''''''
10217	9947	{
10218	9948	{
10219	9949	uint64_t arg = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -10233,16 +9963,16 @@
10233	9963	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10234	9964	}
10235	9965	// ACCUMULATE ARGUMENTS - END
10236		- uint64_t return_to = 18446744073709551171LLU;
	9966	+ uint64_t return_to = 18446744073709551179LLU;
10237	9967	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10238	9968	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10239	9969	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10240	9970	heap.data[0].elem1 = heap.data[0].elem0;
10241	9971	heap.data[0].elem0 = restore;
10242		- state.addr = 18446744073709551484LLU; // 9999999976'''''''''''''''
	9972	+ state.addr = 18446744073709551492LLU; // 999999998D'''''''''''''''
10243	9973	break;
10244	9974	}
10245		- case 18446744073709551171LLU: // 999999993C'''''''''''''''
	9975	+ case 18446744073709551179LLU: // 999999993K'''''''''''''''
10246	9976	{
10247	9977	// RELEASE temporary destructor-variable
10248	9978	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -10287,7 +10017,7 @@
10287	10017	}
10288	10018	break;
10289	10019	}
10290		- case 18446744073709551170LLU: // 999999993B'''''''''''''''
	10020	+ case 18446744073709551178LLU: // 999999993J'''''''''''''''
10291	10021	{
10292	10022	{
10293	10023	uint64_t arg = tree_pop_move(&heap, 3LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -10301,14 +10031,14 @@
10301	10031	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
10302	10032	}
10303	10033	// emitted destructur for type list<varentry__>
10304		- state.addr = 18446744073709551168LLU; // 999999993_'''''''''''''''
	10034	+ state.addr = 18446744073709551176LLU; // 999999993H'''''''''''''''
10305	10035	break;
10306	10036	}
10307		- case 18446744073709551168LLU: // 999999993_'''''''''''''''
	10037	+ case 18446744073709551176LLU: // 999999993H'''''''''''''''
10308	10038	{
10309	10039	if(!LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/list*/)
10310	10040	{
10311		- state.addr = 18446744073709551169LLU; // 999999993A'''''''''''''''
	10041	+ state.addr = 18446744073709551177LLU; // 999999993I'''''''''''''''
10312	10042	break;
10313	10043	}
10314	10044	// temporary list-element

		@@ -10322,23 +10052,23 @@
10322	10052	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10323	10053	}
10324	10054	// ACCUMULATE ARGUMENTS - END
10325		- uint64_t return_to = 18446744073709551167LLU;
	10055	+ uint64_t return_to = 18446744073709551175LLU;
10326	10056	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10327	10057	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10328	10058	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10329	10059	heap.data[0].elem1 = heap.data[0].elem0;
10330	10060	heap.data[0].elem0 = restore;
10331		- state.addr = 18446744073709551172LLU; // 999999993D'''''''''''''''
	10061	+ state.addr = 18446744073709551180LLU; // 999999993L'''''''''''''''
10332	10062	break;
10333	10063	}
10334		- case 18446744073709551167LLU: // 9999999929'''''''''''''''
	10064	+ case 18446744073709551175LLU: // 999999993G'''''''''''''''
10335	10065	{
10336	10066	// RELEASE temporary destructor-variable
10337	10067	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
10338		- state.addr = 18446744073709551168LLU; // 999999993_'''''''''''''''
	10068	+ state.addr = 18446744073709551176LLU; // 999999993H'''''''''''''''
10339	10069	break;
10340	10070	}
10341		- case 18446744073709551169LLU: // 999999993A'''''''''''''''
	10071	+ case 18446744073709551177LLU: // 999999993I'''''''''''''''
10342	10072	{
10343	10073	// RELEASE temporary destructor-variable
10344	10074	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -10353,16 +10083,16 @@
10353	10083	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10354	10084	}
10355	10085	// ACCUMULATE ARGUMENTS - END
10356		- uint64_t return_to = 18446744073709551166LLU;
	10086	+ uint64_t return_to = 18446744073709551174LLU;
10357	10087	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10358	10088	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10359	10089	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10360	10090	heap.data[0].elem1 = heap.data[0].elem0;
10361	10091	heap.data[0].elem0 = restore;
10362		- state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
	10092	+ state.addr = 18446744073709551503LLU; // 999999998O'''''''''''''''
10363	10093	break;
10364	10094	}
10365		- case 18446744073709551166LLU: // 9999999928'''''''''''''''
	10095	+ case 18446744073709551174LLU: // 999999993F'''''''''''''''
10366	10096	{
10367	10097	// RELEASE temporary destructor-variable
10368	10098	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -10414,7 +10144,7 @@
10414	10144	}
10415	10145	break;
10416	10146	}
10417		- case 18446744073709551165LLU: // 9999999927'''''''''''''''
	10147	+ case 18446744073709551173LLU: // 999999993E'''''''''''''''
10418	10148	{
10419	10149	{
10420	10150	uint64_t arg = tree_pop_move(&heap, 3LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -10434,16 +10164,16 @@
10434	10164	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10435	10165	}
10436	10166	// ACCUMULATE ARGUMENTS - END
10437		- uint64_t return_to = 18446744073709551164LLU;
	10167	+ uint64_t return_to = 18446744073709551172LLU;
10438	10168	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10439	10169	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10440	10170	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10441	10171	heap.data[0].elem1 = heap.data[0].elem0;
10442	10172	heap.data[0].elem0 = restore;
10443		- state.addr = 18446744073709551386LLU; // 999999996Z'''''''''''''''
	10173	+ state.addr = 18446744073709551394LLU; // 999999996g'''''''''''''''
10444	10174	break;
10445	10175	}
10446		- case 18446744073709551164LLU: // 9999999926'''''''''''''''
	10176	+ case 18446744073709551172LLU: // 999999993D'''''''''''''''
10447	10177	{
10448	10178	// RELEASE temporary destructor-variable
10449	10179	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -10502,7 +10232,7 @@
10502	10232	}
10503	10233	break;
10504	10234	}
10505		- case 18446744073709551163LLU: // 9999999925'''''''''''''''
	10235	+ case 18446744073709551171LLU: // 999999993C'''''''''''''''
10506	10236	{
10507	10237	{
10508	10238	uint64_t arg = tree_pop_move(&heap, 4LLU, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));

		@@ -10529,16 +10259,16 @@
10529	10259	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10530	10260	}
10531	10261	// ACCUMULATE ARGUMENTS - END
10532		- uint64_t return_to = 18446744073709551162LLU;
	10262	+ uint64_t return_to = 18446744073709551170LLU;
10533	10263	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
10534	10264	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10535	10265	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10536	10266	heap.data[0].elem1 = heap.data[0].elem0;
10537	10267	heap.data[0].elem0 = restore;
10538		- state.addr = 18446744073709551203LLU; // 999999993h'''''''''''''''
	10268	+ state.addr = 18446744073709551211LLU; // 999999993p'''''''''''''''
10539	10269	break;
10540	10270	}
10541		- case 18446744073709551162LLU: // 9999999924'''''''''''''''
	10271	+ case 18446744073709551170LLU: // 999999993B'''''''''''''''
10542	10272	{
10543	10273	// RELEASE temporary destructor-variable
10544	10274	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2

		@@ -10641,7 +10371,7 @@
10641	10371	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10642	10372	}
10643	10373	// ACCUMULATE ARGUMENTS - END
10644		- uint64_t return_to = 18446744073709551159LLU;
	10374	+ uint64_t return_to = 18446744073709551167LLU;
10645	10375	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10646	10376	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10647	10377	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10650,7 +10380,7 @@
10650	10380	state.addr = 552446646280519680LLU; // copyu64___
10651	10381	break;
10652	10382	}
10653		- case 18446744073709551159LLU: // 9999999921'''''''''''''''
	10383	+ case 18446744073709551167LLU: // 9999999929'''''''''''''''
10654	10384	{
10655	10385	{
10656	10386	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -10679,7 +10409,7 @@
10679	10409	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10680	10410	}
10681	10411	// ACCUMULATE ARGUMENTS - END
10682		- uint64_t return_to = 18446744073709551158LLU;
	10412	+ uint64_t return_to = 18446744073709551166LLU;
10683	10413	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10684	10414	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10685	10415	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10688,7 +10418,7 @@
10688	10418	state.addr = 121779622511284459LLU; // FunctionCp
10689	10419	break;
10690	10420	}
10691		- case 18446744073709551158LLU: // 9999999920'''''''''''''''
	10421	+ case 18446744073709551166LLU: // 9999999928'''''''''''''''
10692	10422	{
10693	10423	{
10694	10424	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -10717,7 +10447,7 @@
10717	10447	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10718	10448	}
10719	10449	// ACCUMULATE ARGUMENTS - END
10720		- uint64_t return_to = 18446744073709551157LLU;
	10450	+ uint64_t return_to = 18446744073709551165LLU;
10721	10451	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10722	10452	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10723	10453	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10726,7 +10456,7 @@
10726	10456	state.addr = 552446646280519680LLU; // copyu64___
10727	10457	break;
10728	10458	}
10729		- case 18446744073709551157LLU: // 999999992z'''''''''''''''
	10459	+ case 18446744073709551165LLU: // 9999999927'''''''''''''''
10730	10460	{
10731	10461	{
10732	10462	uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 7*/;

		@@ -10738,7 +10468,7 @@
10738	10468	}
10739	10469	}
10740	10470	// ACCUMULATE ARGUMENTS - END
10741		- uint64_t return_to = 18446744073709551160LLU;
	10471	+ uint64_t return_to = 18446744073709551168LLU;
10742	10472	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
10743	10473	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10744	10474	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10747,7 +10477,7 @@
10747	10477	state.addr = 567601196335104000LLU; // defidfn___
10748	10478	break;
10749	10479	}
10750		- case 18446744073709551160LLU: // 9999999922'''''''''''''''
	10480	+ case 18446744073709551168LLU: // 999999993_'''''''''''''''
10751	10481	{
10752	10482	// parameter-reference u64 defined___ goes out of scope
10753	10483	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defined___ at 5

		@@ -10829,7 +10559,7 @@
10829	10559	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10830	10560	}
10831	10561	// ACCUMULATE ARGUMENTS - END
10832		- uint64_t return_to = 18446744073709551154LLU;
	10562	+ uint64_t return_to = 18446744073709551162LLU;
10833	10563	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10834	10564	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10835	10565	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10838,7 +10568,7 @@
10838	10568	state.addr = 552446646280519680LLU; // copyu64___
10839	10569	break;
10840	10570	}
10841		- case 18446744073709551154LLU: // 999999992w'''''''''''''''
	10571	+ case 18446744073709551162LLU: // 9999999924'''''''''''''''
10842	10572	{
10843	10573	{
10844	10574	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -10867,7 +10597,7 @@
10867	10597	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10868	10598	}
10869	10599	// ACCUMULATE ARGUMENTS - END
10870		- uint64_t return_to = 18446744073709551153LLU;
	10600	+ uint64_t return_to = 18446744073709551161LLU;
10871	10601	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10872	10602	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10873	10603	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10876,7 +10606,7 @@
10876	10606	state.addr = 66057855622447104LLU; // CopyTK____
10877	10607	break;
10878	10608	}
10879		- case 18446744073709551153LLU: // 999999992v'''''''''''''''
	10609	+ case 18446744073709551161LLU: // 9999999923'''''''''''''''
10880	10610	{
10881	10611	{
10882	10612	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -10905,7 +10635,7 @@
10905	10635	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10906	10636	}
10907	10637	// ACCUMULATE ARGUMENTS - END
10908		- uint64_t return_to = 18446744073709551152LLU;
	10638	+ uint64_t return_to = 18446744073709551160LLU;
10909	10639	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10910	10640	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10911	10641	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10914,7 +10644,7 @@
10914	10644	state.addr = 552446646280519680LLU; // copyu64___
10915	10645	break;
10916	10646	}
10917		- case 18446744073709551152LLU: // 999999992u'''''''''''''''
	10647	+ case 18446744073709551160LLU: // 9999999922'''''''''''''''
10918	10648	{
10919	10649	{
10920	10650	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -10943,7 +10673,7 @@
10943	10673	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10944	10674	}
10945	10675	// ACCUMULATE ARGUMENTS - END
10946		- uint64_t return_to = 18446744073709551151LLU;
	10676	+ uint64_t return_to = 18446744073709551159LLU;
10947	10677	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
10948	10678	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10949	10679	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10952,7 +10682,7 @@
10952	10682	state.addr = 552446646280519680LLU; // copyu64___
10953	10683	break;
10954	10684	}
10955		- case 18446744073709551151LLU: // 999999992t'''''''''''''''
	10685	+ case 18446744073709551159LLU: // 9999999921'''''''''''''''
10956	10686	{
10957	10687	{
10958	10688	uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 8*/;

		@@ -10964,7 +10694,7 @@
10964	10694	}
10965	10695	}
10966	10696	// ACCUMULATE ARGUMENTS - END
10967		- uint64_t return_to = 18446744073709551155LLU;
	10697	+ uint64_t return_to = 18446744073709551163LLU;
10968	10698	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
10969	10699	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10970	10700	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -10973,7 +10703,7 @@
10973	10703	state.addr = 861504777589358592LLU; // typedef___
10974	10704	break;
10975	10705	}
10976		- case 18446744073709551155LLU: // 999999992x'''''''''''''''
	10706	+ case 18446744073709551163LLU: // 9999999925'''''''''''''''
10977	10707	{
10978	10708	// parameter-reference u64 destraddr1 goes out of scope
10979	10709	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference destraddr1 at 6

		@@ -11006,10 +10736,10 @@
11006	10736	uint64_t arg = 0;
11007	10737	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
11008	10738	}
11009		- state.addr = 18446744073709551150LLU; // 999999992s'''''''''''''''
	10739	+ state.addr = 18446744073709551158LLU; // 9999999920'''''''''''''''
11010	10740	break;
11011	10741	}
11012		- case 18446744073709551150LLU: // 999999992s'''''''''''''''
	10742	+ case 18446744073709551158LLU: // 9999999920'''''''''''''''
11013	10743	{
11014	10744	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
11015	10745	{

		@@ -11016,7 +10746,7 @@
11016	10746	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
11017	10747	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11018	10748	{
11019		- state.addr = 18446744073709551149LLU; // 999999992r'''''''''''''''
	10749	+ state.addr = 18446744073709551157LLU; // 999999992z'''''''''''''''
11020	10750	break;
11021	10751	}
11022	10752	}

		@@ -11027,25 +10757,25 @@
11027	10757	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
11028	10758	}
11029	10759	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU));
11030		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551148LLU : 18446744073709551147LLU;
	10760	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551156LLU : 18446744073709551155LLU;
11031	10761	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
11032	10762	break;
11033	10763	}
11034		- case 18446744073709551148LLU: // 999999992q'''''''''''''''
	10764	+ case 18446744073709551156LLU: // 999999992y'''''''''''''''
11035	10765	{
11036	10766
11037	10767	access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1;
11038		- state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
	10768	+ state.addr = 18446744073709551155LLU; // 999999992x'''''''''''''''
11039	10769	break;
11040	10770	}
11041		- case 18446744073709551147LLU: // 999999992p'''''''''''''''
	10771	+ case 18446744073709551155LLU: // 999999992x'''''''''''''''
11042	10772	{
11043	10773	// parameter-reference defidfn___ elem______ goes out of scope
11044	10774	// parameter-reference list<defidfn___> fndefs____ goes out of scope
11045		- state.addr = 18446744073709551150LLU; // 999999992s'''''''''''''''
	10775	+ state.addr = 18446744073709551158LLU; // 9999999920'''''''''''''''
11046	10776	break;
11047	10777	}
11048		- case 18446744073709551149LLU: // 999999992r'''''''''''''''
	10778	+ case 18446744073709551157LLU: // 999999992z'''''''''''''''
11049	10779	{
11050	10780	// parameter-reference u64 id________ goes out of scope
11051	10781	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 3

		@@ -11076,10 +10806,10 @@
11076	10806	uint64_t arg = 0;
11077	10807	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
11078	10808	}
11079		- state.addr = 18446744073709551146LLU; // 999999992o'''''''''''''''
	10809	+ state.addr = 18446744073709551154LLU; // 999999992w'''''''''''''''
11080	10810	break;
11081	10811	}
11082		- case 18446744073709551146LLU: // 999999992o'''''''''''''''
	10812	+ case 18446744073709551154LLU: // 999999992w'''''''''''''''
11083	10813	{
11084	10814	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
11085	10815	{

		@@ -11086,7 +10816,7 @@
11086	10816	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
11087	10817	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
11088	10818	{
11089		- state.addr = 18446744073709551145LLU; // 999999992n'''''''''''''''
	10819	+ state.addr = 18446744073709551153LLU; // 999999992v'''''''''''''''
11090	10820	break;
11091	10821	}
11092	10822	}

		@@ -11097,25 +10827,25 @@
11097	10827	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
11098	10828	}
11099	10829	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU), 0LLU));
11100		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551144LLU : 18446744073709551143LLU;
	10830	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551152LLU : 18446744073709551151LLU;
11101	10831	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
11102	10832	break;
11103	10833	}
11104		- case 18446744073709551144LLU: // 999999992m'''''''''''''''
	10834	+ case 18446744073709551152LLU: // 999999992u'''''''''''''''
11105	10835	{
11106	10836
11107	10837	*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) = 1;
11108		- state.addr = 18446744073709551143LLU; // 999999992l'''''''''''''''
	10838	+ state.addr = 18446744073709551151LLU; // 999999992t'''''''''''''''
11109	10839	break;
11110	10840	}
11111		- case 18446744073709551143LLU: // 999999992l'''''''''''''''
	10841	+ case 18446744073709551151LLU: // 999999992t'''''''''''''''
11112	10842	{
11113	10843	// parameter-reference typedef___ elem______ goes out of scope
11114	10844	// parameter-reference list<typedef___> typedefs__ goes out of scope
11115		- state.addr = 18446744073709551146LLU; // 999999992o'''''''''''''''
	10845	+ state.addr = 18446744073709551154LLU; // 999999992w'''''''''''''''
11116	10846	break;
11117	10847	}
11118		- case 18446744073709551145LLU: // 999999992n'''''''''''''''
	10848	+ case 18446744073709551153LLU: // 999999992v'''''''''''''''
11119	10849	{
11120	10850	access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /found_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
11121	10851	// variable u64 found_____ goes out of scope

		@@ -11138,7 +10868,7 @@
11138	10868	{
11139	10869	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 0/typeu64___/)
11140	10870	{
11141		- state.addr = 18446744073709551142LLU; // 999999992k'''''''''''''''
	10871	+ state.addr = 18446744073709551150LLU; // 999999992s'''''''''''''''
11142	10872	break;
11143	10873	}
11144	10874	{

		@@ -11161,11 +10891,11 @@
11161	10891	}
11162	10892	break;
11163	10893	}
11164		- case 18446744073709551142LLU: // 999999992k'''''''''''''''
	10894	+ case 18446744073709551150LLU: // 999999992s'''''''''''''''
11165	10895	{
11166	10896	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 1/typename__/)
11167	10897	{
11168		- state.addr = 18446744073709551141LLU; // 999999992j'''''''''''''''
	10898	+ state.addr = 18446744073709551149LLU; // 999999992r'''''''''''''''
11169	10899	break;
11170	10900	}
11171	10901	{

		@@ -11190,7 +10920,7 @@
11190	10920	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11191	10921	}
11192	10922	// ACCUMULATE ARGUMENTS - END
11193		- uint64_t return_to = 18446744073709551140LLU;
	10923	+ uint64_t return_to = 18446744073709551148LLU;
11194	10924	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
11195	10925	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11196	10926	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11199,7 +10929,7 @@
11199	10929	state.addr = 104588758373059296LLU; // ExistsType
11200	10930	break;
11201	10931	}
11202		- case 18446744073709551140LLU: // 999999992i'''''''''''''''
	10932	+ case 18446744073709551148LLU: // 999999992q'''''''''''''''
11203	10933	{
11204	10934	// parameter-reference u64 maintype__ goes out of scope
11205	10935	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference maintype__ at 5

		@@ -11218,11 +10948,11 @@
11218	10948	}
11219	10949	break;
11220	10950	}
11221		- case 18446744073709551141LLU: // 999999992j'''''''''''''''
	10951	+ case 18446744073709551149LLU: // 999999992r'''''''''''''''
11222	10952	{
11223	10953	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 2/typelist__/)
11224	10954	{
11225		- state.addr = 18446744073709551139LLU; // 999999992h'''''''''''''''
	10955	+ state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
11226	10956	break;
11227	10957	}
11228	10958	{

		@@ -11243,17 +10973,17 @@
11243	10973	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
11244	10974	}
11245	10975	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /sym_______/LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
11246		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551138LLU : 18446744073709551137LLU;
	10976	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551146LLU : 18446744073709551145LLU;
11247	10977	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
11248	10978	break;
11249	10979	}
11250		- case 18446744073709551138LLU: // 999999992g'''''''''''''''
	10980	+ case 18446744073709551146LLU: // 999999992o'''''''''''''''
11251	10981	{
11252	10982	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 1LLU;
11253		- state.addr = 18446744073709551136LLU; // 999999992e'''''''''''''''
	10983	+ state.addr = 18446744073709551144LLU; // 999999992m'''''''''''''''
11254	10984	break;
11255	10985	}
11256		- case 18446744073709551137LLU: // 999999992f'''''''''''''''
	10986	+ case 18446744073709551145LLU: // 999999992n'''''''''''''''
11257	10987	{
11258	10988	// ACCUMULATE ARGUMENTS - BEGIN
11259	10989	{

		@@ -11269,7 +10999,7 @@
11269	10999	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11270	11000	}
11271	11001	// ACCUMULATE ARGUMENTS - END
11272		- uint64_t return_to = 18446744073709551135LLU;
	11002	+ uint64_t return_to = 18446744073709551143LLU;
11273	11003	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
11274	11004	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11275	11005	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11278,12 +11008,12 @@
11278	11008	state.addr = 104588758373059296LLU; // ExistsType
11279	11009	break;
11280	11010	}
11281		- case 18446744073709551135LLU: // 999999992d'''''''''''''''
	11011	+ case 18446744073709551143LLU: // 999999992l'''''''''''''''
11282	11012	{
11283		- state.addr = 18446744073709551136LLU; // 999999992e'''''''''''''''
	11013	+ state.addr = 18446744073709551144LLU; // 999999992m'''''''''''''''
11284	11014	break;
11285	11015	}
11286		- case 18446744073709551136LLU: // 999999992e'''''''''''''''
	11016	+ case 18446744073709551144LLU: // 999999992m'''''''''''''''
11287	11017	{
11288	11018	// variable u64 sym_______ goes out of scope
11289	11019	// emitted destructur for type u64

		@@ -11305,7 +11035,7 @@
11305	11035	}
11306	11036	break;
11307	11037	}
11308		- case 18446744073709551139LLU: // 999999992h'''''''''''''''
	11038	+ case 18446744073709551147LLU: // 999999992p'''''''''''''''
11309	11039	{
11310	11040	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowType__\n");
11311	11041	exit(-1);

		@@ -11315,7 +11045,7 @@
11315	11045	{
11316	11046	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/typeu64___/)
11317	11047	{
11318		- state.addr = 18446744073709551134LLU; // 999999992c'''''''''''''''
	11048	+ state.addr = 18446744073709551142LLU; // 999999992k'''''''''''''''
11319	11049	break;
11320	11050	}
11321	11051	{

		@@ -11340,11 +11070,11 @@
11340	11070	}
11341	11071	break;
11342	11072	}
11343		- case 18446744073709551134LLU: // 999999992c'''''''''''''''
	11073	+ case 18446744073709551142LLU: // 999999992k'''''''''''''''
11344	11074	{
11345	11075	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/typename__/)
11346	11076	{
11347		- state.addr = 18446744073709551133LLU; // 999999992b'''''''''''''''
	11077	+ state.addr = 18446744073709551141LLU; // 999999992j'''''''''''''''
11348	11078	break;
11349	11079	}
11350	11080	{

		@@ -11369,7 +11099,7 @@
11369	11099	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11370	11100	}
11371	11101	// ACCUMULATE ARGUMENTS - END
11372		- uint64_t return_to = 18446744073709551132LLU;
	11102	+ uint64_t return_to = 18446744073709551140LLU;
11373	11103	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
11374	11104	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11375	11105	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11378,7 +11108,7 @@
11378	11108	state.addr = 104588758373059296LLU; // ExistsType
11379	11109	break;
11380	11110	}
11381		- case 18446744073709551132LLU: // 999999992a'''''''''''''''
	11111	+ case 18446744073709551140LLU: // 999999992i'''''''''''''''
11382	11112	{
11383	11113	// parameter-reference u64 __________ goes out of scope
11384	11114	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 6

		@@ -11399,11 +11129,11 @@
11399	11129	}
11400	11130	break;
11401	11131	}
11402		- case 18446744073709551133LLU: // 999999992b'''''''''''''''
	11132	+ case 18446744073709551141LLU: // 999999992j'''''''''''''''
11403	11133	{
11404	11134	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/typelist__/)
11405	11135	{
11406		- state.addr = 18446744073709551131LLU; // 999999992$'''''''''''''''
	11136	+ state.addr = 18446744073709551139LLU; // 999999992h'''''''''''''''
11407	11137	break;
11408	11138	}
11409	11139	{

		@@ -11424,17 +11154,17 @@
11424	11154	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
11425	11155	}
11426	11156	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /sym_______/LOCAL_ACCESS(heap.data, 8LLU, 6LLU) == /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 5LLU));
11427		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551130LLU : 18446744073709551129LLU;
	11157	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551138LLU : 18446744073709551137LLU;
11428	11158	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
11429	11159	break;
11430	11160	}
11431		- case 18446744073709551130LLU: // 999999992Z'''''''''''''''
	11161	+ case 18446744073709551138LLU: // 999999992g'''''''''''''''
11432	11162	{
11433	11163	access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU;
11434		- state.addr = 18446744073709551128LLU; // 999999992X'''''''''''''''
	11164	+ state.addr = 18446744073709551136LLU; // 999999992e'''''''''''''''
11435	11165	break;
11436	11166	}
11437		- case 18446744073709551129LLU: // 999999992Y'''''''''''''''
	11167	+ case 18446744073709551137LLU: // 999999992f'''''''''''''''
11438	11168	{
11439	11169	{
11440	11170	uint64_t arg = 0;

		@@ -11454,7 +11184,7 @@
11454	11184	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11455	11185	}
11456	11186	// ACCUMULATE ARGUMENTS - END
11457		- uint64_t return_to = 18446744073709551124LLU;
	11187	+ uint64_t return_to = 18446744073709551132LLU;
11458	11188	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
11459	11189	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11460	11190	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11463,30 +11193,30 @@
11463	11193	state.addr = 104588758373059296LLU; // ExistsType
11464	11194	break;
11465	11195	}
11466		- case 18446744073709551124LLU: // 999999992T'''''''''''''''
	11196	+ case 18446744073709551132LLU: // 999999992a'''''''''''''''
11467	11197	{
11468		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551127LLU : 18446744073709551126LLU;
	11198	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551135LLU : 18446744073709551134LLU;
11469	11199	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
11470	11200	break;
11471	11201	}
11472		- case 18446744073709551127LLU: // 999999992W'''''''''''''''
	11202	+ case 18446744073709551135LLU: // 999999992d'''''''''''''''
11473	11203	{
11474	11204	access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU;
11475		- state.addr = 18446744073709551125LLU; // 999999992U'''''''''''''''
	11205	+ state.addr = 18446744073709551133LLU; // 999999992b'''''''''''''''
11476	11206	break;
11477	11207	}
11478		- case 18446744073709551126LLU: // 999999992V'''''''''''''''
	11208	+ case 18446744073709551134LLU: // 999999992c'''''''''''''''
11479	11209	{
11480	11210	access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /self______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 3LLU)) == /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 5LLU));
11481		- state.addr = 18446744073709551125LLU; // 999999992U'''''''''''''''
	11211	+ state.addr = 18446744073709551133LLU; // 999999992b'''''''''''''''
11482	11212	break;
11483	11213	}
11484		- case 18446744073709551125LLU: // 999999992U'''''''''''''''
	11214	+ case 18446744073709551133LLU: // 999999992b'''''''''''''''
11485	11215	{
11486		- state.addr = 18446744073709551128LLU; // 999999992X'''''''''''''''
	11216	+ state.addr = 18446744073709551136LLU; // 999999992e'''''''''''''''
11487	11217	break;
11488	11218	}
11489		- case 18446744073709551128LLU: // 999999992X'''''''''''''''
	11219	+ case 18446744073709551136LLU: // 999999992e'''''''''''''''
11490	11220	{
11491	11221	// variable u64 sym_______ goes out of scope
11492	11222	// emitted destructur for type u64

		@@ -11510,7 +11240,7 @@
11510	11240	}
11511	11241	break;
11512	11242	}
11513		- case 18446744073709551131LLU: // 999999992$'''''''''''''''
	11243	+ case 18446744073709551139LLU: // 999999992h'''''''''''''''
11514	11244	{
11515	11245	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowTypeRC\n");
11516	11246	exit(-1);

		@@ -11518,9 +11248,9 @@
11518	11248	}
11519	11249	case 819847183514380911LLU: // reportcont
11520	11250	{
11521		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/produce___/)
	11251	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/consume___/)
11522	11252	{
11523		- state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
	11253	+ state.addr = 18446744073709551131LLU; // 999999992$'''''''''''''''
11524	11254	break;
11525	11255	}
11526	11256	{

		@@ -11527,30 +11257,6 @@
11527	11257	uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
11528	11258	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
11529	11259	}
11530		- fprintf(stderr, "%s", "produce ");
11531		- // parameter-reference continuity __________ goes out of scope
11532		- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2
11533		- // parameter continuity __________ goes out of scope
11534		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 1
11535		- {
11536		- uint64_t baseinfo = heap.data[0].elem1;
11537		- struct pair pair = unpair(&heap, &baseinfo);
11538		- access_heap(heap.data, 1/memory root*/) = pair.elem0;
11539		- state.addr = pair.elem1;
11540		- }
11541		- break;
11542		- }
11543		- case 18446744073709551123LLU: // 999999992S'''''''''''''''
11544		- {
11545		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/consume___/)
11546		- {
11547		- state.addr = 18446744073709551122LLU; // 999999992R'''''''''''''''
11548		- break;
11549		- }
11550		- {
11551		- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
11552		- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
11553		- }
11554	11260	fprintf(stderr, "%s", "consume ");
11555	11261	// parameter-reference continuity __________ goes out of scope
11556	11262	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 2

		@@ -11564,11 +11270,11 @@
11564	11270	}
11565	11271	break;
11566	11272	}
11567		- case 18446744073709551122LLU: // 999999992R'''''''''''''''
	11273	+ case 18446744073709551131LLU: // 999999992$'''''''''''''''
11568	11274	{
11569		- if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/maintain__/)
	11275	+ if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/maintain__/)
11570	11276	{
11571		- state.addr = 18446744073709551121LLU; // 999999992Q'''''''''''''''
	11277	+ state.addr = 18446744073709551130LLU; // 999999992Z'''''''''''''''
11572	11278	break;
11573	11279	}
11574	11280	{

		@@ -11588,7 +11294,7 @@
11588	11294	}
11589	11295	break;
11590	11296	}
11591		- case 18446744073709551121LLU: // 999999992Q'''''''''''''''
	11297	+ case 18446744073709551130LLU: // 999999992Z'''''''''''''''
11592	11298	{
11593	11299	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportcont\n");
11594	11300	exit(-1);

		@@ -11618,7 +11324,7 @@
11618	11324	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11619	11325	}
11620	11326	// ACCUMULATE ARGUMENTS - END
11621		- uint64_t return_to = 18446744073709551119LLU;
	11327	+ uint64_t return_to = 18446744073709551128LLU;
11622	11328	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
11623	11329	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11624	11330	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11627,7 +11333,7 @@
11627	11333	state.addr = 819847183514380911LLU; // reportcont
11628	11334	break;
11629	11335	}
11630		- case 18446744073709551119LLU: // 999999992O'''''''''''''''
	11336	+ case 18446744073709551128LLU: // 999999992X'''''''''''''''
11631	11337	{
11632	11338	{
11633	11339	uint64_t arg = 0;

		@@ -11634,17 +11340,17 @@
11634	11340	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
11635	11341	}
11636	11342	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /mutable___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
11637		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551118LLU : 18446744073709551117LLU;
	11343	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551127LLU : 18446744073709551126LLU;
11638	11344	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
11639	11345	break;
11640	11346	}
11641		- case 18446744073709551118LLU: // 999999992N'''''''''''''''
	11347	+ case 18446744073709551127LLU: // 999999992W'''''''''''''''
11642	11348	{
11643	11349	fprintf(stderr, "%s", "mut ");
11644		- state.addr = 18446744073709551117LLU; // 999999992M'''''''''''''''
	11350	+ state.addr = 18446744073709551126LLU; // 999999992V'''''''''''''''
11645	11351	break;
11646	11352	}
11647		- case 18446744073709551117LLU: // 999999992M'''''''''''''''
	11353	+ case 18446744073709551126LLU: // 999999992V'''''''''''''''
11648	11354	{
11649	11355	// ACCUMULATE ARGUMENTS - BEGIN
11650	11356	{

		@@ -11652,7 +11358,7 @@
11652	11358	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11653	11359	}
11654	11360	// ACCUMULATE ARGUMENTS - END
11655		- uint64_t return_to = 18446744073709551116LLU;
	11361	+ uint64_t return_to = 18446744073709551125LLU;
11656	11362	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
11657	11363	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11658	11364	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11661,7 +11367,7 @@
11661	11367	state.addr = 819847183518878432LLU; // reporttype
11662	11368	break;
11663	11369	}
11664		- case 18446744073709551116LLU: // 999999992L'''''''''''''''
	11370	+ case 18446744073709551125LLU: // 999999992U'''''''''''''''
11665	11371	{
11666	11372	{
11667	11373	uint64_t arg = 0;

		@@ -11668,17 +11374,17 @@
11668	11374	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
11669	11375	}
11670	11376	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /reference_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
11671		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551115LLU : 18446744073709551114LLU;
	11377	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551124LLU : 18446744073709551123LLU;
11672	11378	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
11673	11379	break;
11674	11380	}
11675		- case 18446744073709551115LLU: // 999999992K'''''''''''''''
	11381	+ case 18446744073709551124LLU: // 999999992T'''''''''''''''
11676	11382	{
11677	11383	fprintf(stderr, "%s", " #");
11678		- state.addr = 18446744073709551114LLU; // 999999992J'''''''''''''''
	11384	+ state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
11679	11385	break;
11680	11386	}
11681		- case 18446744073709551114LLU: // 999999992J'''''''''''''''
	11387	+ case 18446744073709551123LLU: // 999999992S'''''''''''''''
11682	11388	{
11683	11389	// parameter-reference u64 reference_ goes out of scope
11684	11390	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference reference_ at 5

		@@ -11718,7 +11424,7 @@
11718	11424	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11719	11425	}
11720	11426	// ACCUMULATE ARGUMENTS - END
11721		- uint64_t return_to = 18446744073709551112LLU;
	11427	+ uint64_t return_to = 18446744073709551121LLU;
11722	11428	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
11723	11429	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11724	11430	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11727,7 +11433,7 @@
11727	11433	state.addr = 819847183518878432LLU; // reporttype
11728	11434	break;
11729	11435	}
11730		- case 18446744073709551112LLU: // 999999992H'''''''''''''''
	11436	+ case 18446744073709551121LLU: // 999999992Q'''''''''''''''
11731	11437	{
11732	11438	{
11733	11439	uint64_t arg = 0;

		@@ -11734,22 +11440,22 @@
11734	11440	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
11735	11441	}
11736	11442	LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /reference_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
11737		- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551111LLU : 18446744073709551110LLU;
	11443	+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551120LLU : 18446744073709551119LLU;
11738	11444	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
11739	11445	break;
11740	11446	}
11741		- case 18446744073709551111LLU: // 999999992G'''''''''''''''
	11447	+ case 18446744073709551120LLU: // 999999992P'''''''''''''''
11742	11448	{
11743		- state.addr = 18446744073709551109LLU; // 999999992E'''''''''''''''
	11449	+ state.addr = 18446744073709551118LLU; // 999999992N'''''''''''''''
11744	11450	break;
11745	11451	}
11746		- case 18446744073709551110LLU: // 999999992F'''''''''''''''
	11452	+ case 18446744073709551119LLU: // 999999992O'''''''''''''''
11747	11453	{
11748	11454	fprintf(stderr, "%s", "#");
11749		- state.addr = 18446744073709551109LLU; // 999999992E'''''''''''''''
	11455	+ state.addr = 18446744073709551118LLU; // 999999992N'''''''''''''''
11750	11456	break;
11751	11457	}
11752		- case 18446744073709551109LLU: // 999999992E'''''''''''''''
	11458	+ case 18446744073709551118LLU: // 999999992N'''''''''''''''
11753	11459	{
11754	11460	fprintf(stderr, "%s", "(");
11755	11461	fprintf(stderr, "%llu", (unsigned long long)/idx_______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU)));

		@@ -11786,7 +11492,7 @@
11786	11492	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11787	11493	}
11788	11494	// ACCUMULATE ARGUMENTS - END
11789		- uint64_t return_to = 18446744073709551107LLU;
	11495	+ uint64_t return_to = 18446744073709551116LLU;
11790	11496	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
11791	11497	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11792	11498	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11795,7 +11501,7 @@
11795	11501	state.addr = 819847183518878432LLU; // reporttype
11796	11502	break;
11797	11503	}
11798		- case 18446744073709551107LLU: // 999999992C'''''''''''''''
	11504	+ case 18446744073709551116LLU: // 999999992L'''''''''''''''
11799	11505	{
11800	11506	fprintf(stderr, "%s", " ");
11801	11507	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU)));

		@@ -11820,11 +11526,11 @@
11820	11526	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
11821	11527	}
11822	11528	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /safe______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
11823		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551106LLU : 18446744073709551105LLU;
	11529	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551115LLU : 18446744073709551114LLU;
11824	11530	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11825	11531	break;
11826	11532	}
11827		- case 18446744073709551106LLU: // 999999992B'''''''''''''''
	11533	+ case 18446744073709551115LLU: // 999999992K'''''''''''''''
11828	11534	{
11829	11535	{
11830	11536	uint64_t arg = 0;

		@@ -11831,11 +11537,11 @@
11831	11537	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
11832	11538	}
11833	11539	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /finite____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
11834		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551103LLU : 18446744073709551102LLU;
	11540	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551112LLU : 18446744073709551111LLU;
11835	11541	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11836	11542	break;
11837	11543	}
11838		- case 18446744073709551103LLU: // 9999999919'''''''''''''''
	11544	+ case 18446744073709551112LLU: // 999999992H'''''''''''''''
11839	11545	{
11840	11546	{
11841	11547	uint64_t arg = 0;

		@@ -11842,28 +11548,28 @@
11842	11548	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
11843	11549	}
11844	11550	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /complete__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
11845		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551100LLU : 18446744073709551099LLU;
	11551	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551109LLU : 18446744073709551108LLU;
11846	11552	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11847	11553	break;
11848	11554	}
11849		- case 18446744073709551100LLU: // 9999999916'''''''''''''''
	11555	+ case 18446744073709551109LLU: // 999999992E'''''''''''''''
11850	11556	{
11851	11557	fprintf(stderr, "%s", "total");
11852		- state.addr = 18446744073709551098LLU; // 9999999914'''''''''''''''
	11558	+ state.addr = 18446744073709551107LLU; // 999999992C'''''''''''''''
11853	11559	break;
11854	11560	}
11855		- case 18446744073709551099LLU: // 9999999915'''''''''''''''
	11561	+ case 18446744073709551108LLU: // 999999992D'''''''''''''''
11856	11562	{
11857	11563	fprintf(stderr, "%s", "finite");
11858		- state.addr = 18446744073709551098LLU; // 9999999914'''''''''''''''
	11564	+ state.addr = 18446744073709551107LLU; // 999999992C'''''''''''''''
11859	11565	break;
11860	11566	}
11861		- case 18446744073709551098LLU: // 9999999914'''''''''''''''
	11567	+ case 18446744073709551107LLU: // 999999992C'''''''''''''''
11862	11568	{
11863		- state.addr = 18446744073709551101LLU; // 9999999917'''''''''''''''
	11569	+ state.addr = 18446744073709551110LLU; // 999999992F'''''''''''''''
11864	11570	break;
11865	11571	}
11866		- case 18446744073709551102LLU: // 9999999918'''''''''''''''
	11572	+ case 18446744073709551111LLU: // 999999992G'''''''''''''''
11867	11573	{
11868	11574	{
11869	11575	uint64_t arg = 0;

		@@ -11870,39 +11576,39 @@
11870	11576	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
11871	11577	}
11872	11578	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /complete__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
11873		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551097LLU : 18446744073709551096LLU;
	11579	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551106LLU : 18446744073709551105LLU;
11874	11580	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11875	11581	break;
11876	11582	}
11877		- case 18446744073709551097LLU: // 9999999913'''''''''''''''
	11583	+ case 18446744073709551106LLU: // 999999992B'''''''''''''''
11878	11584	{
11879	11585	fprintf(stderr, "%s", "complete");
11880		- state.addr = 18446744073709551095LLU; // 9999999911'''''''''''''''
	11586	+ state.addr = 18446744073709551104LLU; // 999999992_'''''''''''''''
11881	11587	break;
11882	11588	}
11883		- case 18446744073709551096LLU: // 9999999912'''''''''''''''
	11589	+ case 18446744073709551105LLU: // 999999992A'''''''''''''''
11884	11590	{
11885	11591	fprintf(stderr, "%s", "partial");
11886		- state.addr = 18446744073709551095LLU; // 9999999911'''''''''''''''
	11592	+ state.addr = 18446744073709551104LLU; // 999999992_'''''''''''''''
11887	11593	break;
11888	11594	}
11889		- case 18446744073709551095LLU: // 9999999911'''''''''''''''
	11595	+ case 18446744073709551104LLU: // 999999992_'''''''''''''''
11890	11596	{
11891		- state.addr = 18446744073709551101LLU; // 9999999917'''''''''''''''
	11597	+ state.addr = 18446744073709551110LLU; // 999999992F'''''''''''''''
11892	11598	break;
11893	11599	}
11894		- case 18446744073709551101LLU: // 9999999917'''''''''''''''
	11600	+ case 18446744073709551110LLU: // 999999992F'''''''''''''''
11895	11601	{
11896		- state.addr = 18446744073709551104LLU; // 999999992_'''''''''''''''
	11602	+ state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
11897	11603	break;
11898	11604	}
11899		- case 18446744073709551105LLU: // 999999992A'''''''''''''''
	11605	+ case 18446744073709551114LLU: // 999999992J'''''''''''''''
11900	11606	{
11901	11607	fprintf(stderr, "%s", "unsafe");
11902		- state.addr = 18446744073709551104LLU; // 999999992_'''''''''''''''
	11608	+ state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
11903	11609	break;
11904	11610	}
11905		- case 18446744073709551104LLU: // 999999992_'''''''''''''''
	11611	+ case 18446744073709551113LLU: // 999999992I'''''''''''''''
11906	11612	{
11907	11613	// parameter-reference u64 safe______ goes out of scope
11908	11614	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference safe______ at 3

		@@ -11934,7 +11640,7 @@
11934	11640	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11935	11641	}
11936	11642	// ACCUMULATE ARGUMENTS - END
11937		- uint64_t return_to = 18446744073709551094LLU;
	11643	+ uint64_t return_to = 18446744073709551103LLU;
11938	11644	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
11939	11645	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11940	11646	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11943,7 +11649,7 @@
11943	11649	state.addr = 819847183514344320LLU; // reportcfs_
11944	11650	break;
11945	11651	}
11946		- case 18446744073709551094LLU: // 9999999910'''''''''''''''
	11652	+ case 18446744073709551103LLU: // 9999999919'''''''''''''''
11947	11653	{
11948	11654	fprintf(stderr, "%s", " ");
11949	11655	fprintf(stderr, "%s", "(");

		@@ -11955,10 +11661,10 @@
11955	11661	uint64_t arg = 0;
11956	11662	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
11957	11663	}
11958		- state.addr = 18446744073709551093LLU; // 999999991z'''''''''''''''
	11664	+ state.addr = 18446744073709551102LLU; // 9999999918'''''''''''''''
11959	11665	break;
11960	11666	}
11961		- case 18446744073709551093LLU: // 999999991z'''''''''''''''
	11667	+ case 18446744073709551102LLU: // 9999999918'''''''''''''''
11962	11668	{
11963	11669	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
11964	11670	{

		@@ -11965,7 +11671,7 @@
11965	11671	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
11966	11672	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
11967	11673	{
11968		- state.addr = 18446744073709551092LLU; // 999999991y'''''''''''''''
	11674	+ state.addr = 18446744073709551101LLU; // 9999999917'''''''''''''''
11969	11675	break;
11970	11676	}
11971	11677	}

		@@ -11977,7 +11683,7 @@
11977	11683	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
11978	11684	}
11979	11685	// ACCUMULATE ARGUMENTS - END
11980		- uint64_t return_to = 18446744073709551091LLU;
	11686	+ uint64_t return_to = 18446744073709551100LLU;
11981	11687	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
11982	11688	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
11983	11689	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -11986,14 +11692,14 @@
11986	11692	state.addr = 819847183518272384LLU; // reportres_
11987	11693	break;
11988	11694	}
11989		- case 18446744073709551091LLU: // 999999991x'''''''''''''''
	11695	+ case 18446744073709551100LLU: // 9999999916'''''''''''''''
11990	11696	{
11991	11697	// parameter-reference resdest___ par_______ goes out of scope
11992	11698	// parameter-reference function__ kind______ goes out of scope
11993		- state.addr = 18446744073709551093LLU; // 999999991z'''''''''''''''
	11699	+ state.addr = 18446744073709551102LLU; // 9999999918'''''''''''''''
11994	11700	break;
11995	11701	}
11996		- case 18446744073709551092LLU: // 999999991y'''''''''''''''
	11702	+ case 18446744073709551101LLU: // 9999999917'''''''''''''''
11997	11703	{
11998	11704	fprintf(stderr, "%s", ") ");
11999	11705	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)));

		@@ -12006,10 +11712,10 @@
12006	11712	uint64_t arg = 0;
12007	11713	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
12008	11714	}
12009		- state.addr = 18446744073709551090LLU; // 999999991w'''''''''''''''
	11715	+ state.addr = 18446744073709551099LLU; // 9999999915'''''''''''''''
12010	11716	break;
12011	11717	}
12012		- case 18446744073709551090LLU: // 999999991w'''''''''''''''
	11718	+ case 18446744073709551099LLU: // 9999999915'''''''''''''''
12013	11719	{
12014	11720	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
12015	11721	{

		@@ -12016,7 +11722,7 @@
12016	11722	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
12017	11723	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
12018	11724	{
12019		- state.addr = 18446744073709551089LLU; // 999999991v'''''''''''''''
	11725	+ state.addr = 18446744073709551098LLU; // 9999999914'''''''''''''''
12020	11726	break;
12021	11727	}
12022	11728	}

		@@ -12028,7 +11734,7 @@
12028	11734	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12029	11735	}
12030	11736	// ACCUMULATE ARGUMENTS - END
12031		- uint64_t return_to = 18446744073709551088LLU;
	11737	+ uint64_t return_to = 18446744073709551097LLU;
12032	11738	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12033	11739	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12034	11740	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12037,15 +11743,15 @@
12037	11743	state.addr = 819847183517731648LLU; // reportpar_
12038	11744	break;
12039	11745	}
12040		- case 18446744073709551088LLU: // 999999991u'''''''''''''''
	11746	+ case 18446744073709551097LLU: // 9999999913'''''''''''''''
12041	11747	{
12042	11748	fprintf(stderr, "%s", " ");
12043	11749	// parameter-reference pardef____ par_______ goes out of scope
12044	11750	// parameter-reference function__ kind______ goes out of scope
12045		- state.addr = 18446744073709551090LLU; // 999999991w'''''''''''''''
	11751	+ state.addr = 18446744073709551099LLU; // 9999999915'''''''''''''''
12046	11752	break;
12047	11753	}
12048		- case 18446744073709551089LLU: // 999999991v'''''''''''''''
	11754	+ case 18446744073709551098LLU: // 9999999914'''''''''''''''
12049	11755	{
12050	11756	fprintf(stderr, "%s", ") ");
12051	11757	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -12054,7 +11760,7 @@
12054	11760	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12055	11761	}
12056	11762	// ACCUMULATE ARGUMENTS - END
12057		- uint64_t return_to = 18446744073709551087LLU;
	11763	+ uint64_t return_to = 18446744073709551096LLU;
12058	11764	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12059	11765	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12060	11766	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12063,7 +11769,7 @@
12063	11769	state.addr = 819847183517274112LLU; // reportnr__
12064	11770	break;
12065	11771	}
12066		- case 18446744073709551087LLU: // 999999991t'''''''''''''''
	11772	+ case 18446744073709551096LLU: // 9999999912'''''''''''''''
12067	11773	{
12068	11774	fprintf(stderr, "%s", " ");
12069	11775	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -12072,7 +11778,7 @@
12072	11778	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12073	11779	}
12074	11780	// ACCUMULATE ARGUMENTS - END
12075		- uint64_t return_to = 18446744073709551086LLU;
	11781	+ uint64_t return_to = 18446744073709551095LLU;
12076	11782	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12077	11783	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12078	11784	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12081,7 +11787,7 @@
12081	11787	state.addr = 819847183517274112LLU; // reportnr__
12082	11788	break;
12083	11789	}
12084		- case 18446744073709551086LLU: // 999999991s'''''''''''''''
	11790	+ case 18446744073709551095LLU: // 9999999911'''''''''''''''
12085	11791	{
12086	11792	fprintf(stderr, "%s", " ");
12087	11793	{

		@@ -12089,23 +11795,23 @@
12089	11795	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
12090	11796	}
12091	11797	LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /defined___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
12092		- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551085LLU : 18446744073709551084LLU;
	11798	+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551094LLU : 18446744073709551093LLU;
12093	11799	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
12094	11800	break;
12095	11801	}
12096		- case 18446744073709551085LLU: // 999999991r'''''''''''''''
	11802	+ case 18446744073709551094LLU: // 9999999910'''''''''''''''
12097	11803	{
12098	11804	fprintf(stderr, "%s", "DEFINITION");
12099		- state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
	11805	+ state.addr = 18446744073709551092LLU; // 999999991y'''''''''''''''
12100	11806	break;
12101	11807	}
12102		- case 18446744073709551084LLU: // 999999991q'''''''''''''''
	11808	+ case 18446744073709551093LLU: // 999999991z'''''''''''''''
12103	11809	{
12104	11810	fprintf(stderr, "%s", "DECLARATION");
12105		- state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
	11811	+ state.addr = 18446744073709551092LLU; // 999999991y'''''''''''''''
12106	11812	break;
12107	11813	}
12108		- case 18446744073709551083LLU: // 999999991p'''''''''''''''
	11814	+ case 18446744073709551092LLU: // 999999991y'''''''''''''''
12109	11815	{
12110	11816	fprintf(stderr, "%s", " <- possibly REVERSED parameters!");
12111	11817	fprintf(stderr, "%s", "\n");

		@@ -12133,10 +11839,10 @@
12133	11839	uint64_t arg = 0;
12134	11840	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
12135	11841	}
12136		- state.addr = 18446744073709551082LLU; // 999999991o'''''''''''''''
	11842	+ state.addr = 18446744073709551091LLU; // 999999991x'''''''''''''''
12137	11843	break;
12138	11844	}
12139		- case 18446744073709551082LLU: // 999999991o'''''''''''''''
	11845	+ case 18446744073709551091LLU: // 999999991x'''''''''''''''
12140	11846	{
12141	11847	if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
12142	11848	{

		@@ -12143,7 +11849,7 @@
12143	11849	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
12144	11850	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
12145	11851	{
12146		- state.addr = 18446744073709551081LLU; // 999999991n'''''''''''''''
	11852	+ state.addr = 18446744073709551090LLU; // 999999991w'''''''''''''''
12147	11853	break;
12148	11854	}
12149	11855	}

		@@ -12163,7 +11869,7 @@
12163	11869	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12164	11870	}
12165	11871	// ACCUMULATE ARGUMENTS - END
12166		- uint64_t return_to = 18446744073709551080LLU;
	11872	+ uint64_t return_to = 18446744073709551089LLU;
12167	11873	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
12168	11874	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12169	11875	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12172,14 +11878,14 @@
12172	11878	state.addr = 819847183514601536LLU; // reportdef_
12173	11879	break;
12174	11880	}
12175		- case 18446744073709551080LLU: // 999999991m'''''''''''''''
	11881	+ case 18446744073709551089LLU: // 999999991v'''''''''''''''
12176	11882	{
12177	11883	// parameter-reference defidfn___ def_______ goes out of scope
12178	11884	// parameter-reference list<defidfn___> fndefs____ goes out of scope
12179		- state.addr = 18446744073709551082LLU; // 999999991o'''''''''''''''
	11885	+ state.addr = 18446744073709551091LLU; // 999999991x'''''''''''''''
12180	11886	break;
12181	11887	}
12182		- case 18446744073709551081LLU: // 999999991n'''''''''''''''
	11888	+ case 18446744073709551090LLU: // 999999991w'''''''''''''''
12183	11889	{
12184	11890	// parameter-reference list<defidfn___> fndefs____ goes out of scope
12185	11891	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fndefs____ at 2

		@@ -12213,10 +11919,10 @@
12213	11919	uint64_t arg = 0;
12214	11920	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
12215	11921	}
12216		- state.addr = 18446744073709551078LLU; // 999999991k'''''''''''''''
	11922	+ state.addr = 18446744073709551087LLU; // 999999991t'''''''''''''''
12217	11923	break;
12218	11924	}
12219		- case 18446744073709551078LLU: // 999999991k'''''''''''''''
	11925	+ case 18446744073709551087LLU: // 999999991t'''''''''''''''
12220	11926	{
12221	11927	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
12222	11928	{

		@@ -12223,7 +11929,7 @@
12223	11929	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
12224	11930	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
12225	11931	{
12226		- state.addr = 18446744073709551077LLU; // 999999991j'''''''''''''''
	11932	+ state.addr = 18446744073709551086LLU; // 999999991s'''''''''''''''
12227	11933	break;
12228	11934	}
12229	11935	}

		@@ -12238,7 +11944,7 @@
12238	11944	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12239	11945	}
12240	11946	// ACCUMULATE ARGUMENTS - END
12241		- uint64_t return_to = 18446744073709551076LLU;
	11947	+ uint64_t return_to = 18446744073709551085LLU;
12242	11948	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12243	11949	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12244	11950	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12247,14 +11953,14 @@
12247	11953	state.addr = 819847183518878432LLU; // reporttype
12248	11954	break;
12249	11955	}
12250		- case 18446744073709551076LLU: // 999999991i'''''''''''''''
	11956	+ case 18446744073709551085LLU: // 999999991r'''''''''''''''
12251	11957	{
12252	11958	// parameter-reference elemdef___ elem______ goes out of scope
12253	11959	// parameter-reference list<elemdef___> elems_____ goes out of scope
12254		- state.addr = 18446744073709551078LLU; // 999999991k'''''''''''''''
	11960	+ state.addr = 18446744073709551087LLU; // 999999991t'''''''''''''''
12255	11961	break;
12256	11962	}
12257		- case 18446744073709551077LLU: // 999999991j'''''''''''''''
	11963	+ case 18446744073709551086LLU: // 999999991s'''''''''''''''
12258	11964	{
12259	11965	fprintf(stderr, "%s", ")");
12260	11966	// parameter-reference list<elemdef___> elems_____ goes out of scope

		@@ -12275,7 +11981,7 @@
12275	11981	{
12276	11982	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/tkstruct__/)
12277	11983	{
12278		- state.addr = 18446744073709551075LLU; // 999999991h'''''''''''''''
	11984	+ state.addr = 18446744073709551084LLU; // 999999991q'''''''''''''''
12279	11985	break;
12280	11986	}
12281	11987	{

		@@ -12297,10 +12003,10 @@
12297	12003	uint64_t arg = 0;
12298	12004	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
12299	12005	}
12300		- state.addr = 18446744073709551074LLU; // 999999991g'''''''''''''''
	12006	+ state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
12301	12007	break;
12302	12008	}
12303		- case 18446744073709551074LLU: // 999999991g'''''''''''''''
	12009	+ case 18446744073709551083LLU: // 999999991p'''''''''''''''
12304	12010	{
12305	12011	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
12306	12012	{

		@@ -12307,7 +12013,7 @@
12307	12013	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
12308	12014	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
12309	12015	{
12310		- state.addr = 18446744073709551073LLU; // 999999991f'''''''''''''''
	12016	+ state.addr = 18446744073709551082LLU; // 999999991o'''''''''''''''
12311	12017	break;
12312	12018	}
12313	12019	}

		@@ -12319,7 +12025,7 @@
12319	12025	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12320	12026	}
12321	12027	// ACCUMULATE ARGUMENTS - END
12322		- uint64_t return_to = 18446744073709551072LLU;
	12028	+ uint64_t return_to = 18446744073709551081LLU;
12323	12029	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12324	12030	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12325	12031	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12328,15 +12034,15 @@
12328	12034	state.addr = 819847183514892328LLU; // reportelem
12329	12035	break;
12330	12036	}
12331		- case 18446744073709551072LLU: // 999999991e'''''''''''''''
	12037	+ case 18446744073709551081LLU: // 999999991n'''''''''''''''
12332	12038	{
12333	12039	fprintf(stderr, "%s", " ");
12334	12040	// parameter-reference elemdef___ par_______ goes out of scope
12335	12041	// parameter-reference list<elemdef___> defpars___ goes out of scope
12336		- state.addr = 18446744073709551074LLU; // 999999991g'''''''''''''''
	12042	+ state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
12337	12043	break;
12338	12044	}
12339		- case 18446744073709551073LLU: // 999999991f'''''''''''''''
	12045	+ case 18446744073709551082LLU: // 999999991o'''''''''''''''
12340	12046	{
12341	12047	fprintf(stderr, "%s", ");");
12342	12048	// parameter-reference list<elemdef___> defpars___ goes out of scope

		@@ -12355,11 +12061,11 @@
12355	12061	}
12356	12062	break;
12357	12063	}
12358		- case 18446744073709551075LLU: // 999999991h'''''''''''''''
	12064	+ case 18446744073709551084LLU: // 999999991q'''''''''''''''
12359	12065	{
12360	12066	if(heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/tkunion___/)
12361	12067	{
12362		- state.addr = 18446744073709551071LLU; // 999999991d'''''''''''''''
	12068	+ state.addr = 18446744073709551080LLU; // 999999991m'''''''''''''''
12363	12069	break;
12364	12070	}
12365	12071	{

		@@ -12381,10 +12087,10 @@
12381	12087	uint64_t arg = 0;
12382	12088	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
12383	12089	}
12384		- state.addr = 18446744073709551070LLU; // 999999991c'''''''''''''''
	12090	+ state.addr = 18446744073709551079LLU; // 999999991l'''''''''''''''
12385	12091	break;
12386	12092	}
12387		- case 18446744073709551070LLU: // 999999991c'''''''''''''''
	12093	+ case 18446744073709551079LLU: // 999999991l'''''''''''''''
12388	12094	{
12389	12095	if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
12390	12096	{

		@@ -12391,7 +12097,7 @@
12391	12097	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
12392	12098	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
12393	12099	{
12394		- state.addr = 18446744073709551069LLU; // 999999991b'''''''''''''''
	12100	+ state.addr = 18446744073709551078LLU; // 999999991k'''''''''''''''
12395	12101	break;
12396	12102	}
12397	12103	}

		@@ -12404,7 +12110,7 @@
12404	12110	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12405	12111	}
12406	12112	// ACCUMULATE ARGUMENTS - END
12407		- uint64_t return_to = 18446744073709551068LLU;
	12113	+ uint64_t return_to = 18446744073709551077LLU;
12408	12114	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12409	12115	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12410	12116	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12413,14 +12119,14 @@
12413	12119	state.addr = 325737967259227264LLU; // REPORTVAR_
12414	12120	break;
12415	12121	}
12416		- case 18446744073709551068LLU: // 999999991a'''''''''''''''
	12122	+ case 18446744073709551077LLU: // 999999991j'''''''''''''''
12417	12123	{
12418	12124	// parameter-reference variant___ constr____ goes out of scope
12419	12125	// parameter-reference list<variant___> constrs___ goes out of scope
12420		- state.addr = 18446744073709551070LLU; // 999999991c'''''''''''''''
	12126	+ state.addr = 18446744073709551079LLU; // 999999991l'''''''''''''''
12421	12127	break;
12422	12128	}
12423		- case 18446744073709551069LLU: // 999999991b'''''''''''''''
	12129	+ case 18446744073709551078LLU: // 999999991k'''''''''''''''
12424	12130	{
12425	12131	fprintf(stderr, "%s", ";");
12426	12132	// parameter-reference list<variant___> constrs___ goes out of scope

		@@ -12439,7 +12145,7 @@
12439	12145	}
12440	12146	break;
12441	12147	}
12442		- case 18446744073709551071LLU: // 999999991d'''''''''''''''
	12148	+ case 18446744073709551080LLU: // 999999991m'''''''''''''''
12443	12149	{
12444	12150	fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttyp_\n");
12445	12151	exit(-1);

		@@ -12455,10 +12161,10 @@
12455	12161	uint64_t arg = 0;
12456	12162	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
12457	12163	}
12458		- state.addr = 18446744073709551067LLU; // 999999991$'''''''''''''''
	12164	+ state.addr = 18446744073709551076LLU; // 999999991i'''''''''''''''
12459	12165	break;
12460	12166	}
12461		- case 18446744073709551067LLU: // 999999991$'''''''''''''''
	12167	+ case 18446744073709551076LLU: // 999999991i'''''''''''''''
12462	12168	{
12463	12169	if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
12464	12170	{

		@@ -12465,7 +12171,7 @@
12465	12171	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
12466	12172	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
12467	12173	{
12468		- state.addr = 18446744073709551066LLU; // 999999991Z'''''''''''''''
	12174	+ state.addr = 18446744073709551075LLU; // 999999991h'''''''''''''''
12469	12175	break;
12470	12176	}
12471	12177	}

		@@ -12482,7 +12188,7 @@
12482	12188	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12483	12189	}
12484	12190	// ACCUMULATE ARGUMENTS - END
12485		- uint64_t return_to = 18446744073709551065LLU;
	12191	+ uint64_t return_to = 18446744073709551074LLU;
12486	12192	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12487	12193	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12488	12194	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12491,7 +12197,7 @@
12491	12197	state.addr = 819847183518878400LLU; // reporttyp_
12492	12198	break;
12493	12199	}
12494		- case 18446744073709551065LLU: // 999999991Y'''''''''''''''
	12200	+ case 18446744073709551074LLU: // 999999991g'''''''''''''''
12495	12201	{
12496	12202	fprintf(stderr, "%s", " 0 ");
12497	12203	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -12500,7 +12206,7 @@
12500	12206	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12501	12207	}
12502	12208	// ACCUMULATE ARGUMENTS - END
12503		- uint64_t return_to = 18446744073709551064LLU;
	12209	+ uint64_t return_to = 18446744073709551073LLU;
12504	12210	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
12505	12211	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12506	12212	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12509,7 +12215,7 @@
12509	12215	state.addr = 819847183517274112LLU; // reportnr__
12510	12216	break;
12511	12217	}
12512		- case 18446744073709551064LLU: // 999999991X'''''''''''''''
	12218	+ case 18446744073709551073LLU: // 999999991f'''''''''''''''
12513	12219	{
12514	12220	{
12515	12221	uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);

		@@ -12532,17 +12238,17 @@
12532	12238	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
12533	12239	}
12534	12240	LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /destraddr_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU));
12535		- state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551063LLU : 18446744073709551062LLU;
	12241	+ state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551072LLU : 18446744073709551071LLU;
12536	12242	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
12537	12243	break;
12538	12244	}
12539		- case 18446744073709551063LLU: // 999999991W'''''''''''''''
	12245	+ case 18446744073709551072LLU: // 999999991e'''''''''''''''
12540	12246	{
12541	12247	fprintf(stderr, "%s", " capability release");
12542		- state.addr = 18446744073709551062LLU; // 999999991V'''''''''''''''
	12248	+ state.addr = 18446744073709551071LLU; // 999999991d'''''''''''''''
12543	12249	break;
12544	12250	}
12545		- case 18446744073709551062LLU: // 999999991V'''''''''''''''
	12251	+ case 18446744073709551071LLU: // 999999991d'''''''''''''''
12546	12252	{
12547	12253	// parameter-reference u64 destraddr_ goes out of scope
12548	12254	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference destraddr_ at 8

		@@ -12554,10 +12260,10 @@
12554	12260	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 5
12555	12261	// parameter-reference typedef___ def_______ goes out of scope
12556	12262	// parameter-reference list<typedef___> typedefs__ goes out of scope
12557		- state.addr = 18446744073709551067LLU; // 999999991$'''''''''''''''
	12263	+ state.addr = 18446744073709551076LLU; // 999999991i'''''''''''''''
12558	12264	break;
12559	12265	}
12560		- case 18446744073709551066LLU: // 999999991Z'''''''''''''''
	12266	+ case 18446744073709551075LLU: // 999999991h'''''''''''''''
12561	12267	{
12562	12268	// parameter-reference list<typedef___> typedefs__ goes out of scope
12563	12269	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedefs__ at 2

		@@ -12578,11 +12284,11 @@
12578	12284	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
12579	12285	}
12580	12286	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /complete__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
12581		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551061LLU : 18446744073709551060LLU;
	12287	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551070LLU : 18446744073709551069LLU;
12582	12288	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12583	12289	break;
12584	12290	}
12585		- case 18446744073709551061LLU: // 999999991U'''''''''''''''
	12291	+ case 18446744073709551070LLU: // 999999991c'''''''''''''''
12586	12292	{
12587	12293	{
12588	12294	uint64_t arg = 0;

		@@ -12598,7 +12304,7 @@
12598	12304	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12599	12305	}
12600	12306	// ACCUMULATE ARGUMENTS - END
12601		- uint64_t return_to = 18446744073709551056LLU;
	12307	+ uint64_t return_to = 18446744073709551065LLU;
12602	12308	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12603	12309	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12604	12310	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12607,18 +12313,18 @@
12607	12313	state.addr = 606150496152849376LLU; // fncomplete
12608	12314	break;
12609	12315	}
12610		- case 18446744073709551056LLU: // 999999991P'''''''''''''''
	12316	+ case 18446744073709551065LLU: // 999999991Y'''''''''''''''
12611	12317	{
12612		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551059LLU : 18446744073709551058LLU;
	12318	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551068LLU : 18446744073709551067LLU;
12613	12319	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12614	12320	break;
12615	12321	}
12616		- case 18446744073709551059LLU: // 999999991S'''''''''''''''
	12322	+ case 18446744073709551068LLU: // 999999991a'''''''''''''''
12617	12323	{
12618		- state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
	12324	+ state.addr = 18446744073709551066LLU; // 999999991Z'''''''''''''''
12619	12325	break;
12620	12326	}
12621		- case 18446744073709551058LLU: // 999999991R'''''''''''''''
	12327	+ case 18446744073709551067LLU: // 999999991$'''''''''''''''
12622	12328	{
12623	12329	fprintf(stderr, "%s", "function ");
12624	12330	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)));

		@@ -12630,15 +12336,15 @@
12630	12336	fprintf(stderr, "%s\n", "");
12631	12337	exit(-1);
12632	12338	}
12633		- state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
	12339	+ state.addr = 18446744073709551066LLU; // 999999991Z'''''''''''''''
12634	12340	break;
12635	12341	}
12636		- case 18446744073709551057LLU: // 999999991Q'''''''''''''''
	12342	+ case 18446744073709551066LLU: // 999999991Z'''''''''''''''
12637	12343	{
12638		- state.addr = 18446744073709551060LLU; // 999999991T'''''''''''''''
	12344	+ state.addr = 18446744073709551069LLU; // 999999991b'''''''''''''''
12639	12345	break;
12640	12346	}
12641		- case 18446744073709551060LLU: // 999999991T'''''''''''''''
	12347	+ case 18446744073709551069LLU: // 999999991b'''''''''''''''
12642	12348	{
12643	12349	{
12644	12350	uint64_t arg = 0;

		@@ -12645,11 +12351,11 @@
12645	12351	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
12646	12352	}
12647	12353	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /finite____/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
12648		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551055LLU : 18446744073709551054LLU;
	12354	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551064LLU : 18446744073709551063LLU;
12649	12355	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12650	12356	break;
12651	12357	}
12652		- case 18446744073709551055LLU: // 999999991O'''''''''''''''
	12358	+ case 18446744073709551064LLU: // 999999991X'''''''''''''''
12653	12359	{
12654	12360	{
12655	12361	uint64_t arg = 0;

		@@ -12665,7 +12371,7 @@
12665	12371	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12666	12372	}
12667	12373	// ACCUMULATE ARGUMENTS - END
12668		- uint64_t return_to = 18446744073709551050LLU;
	12374	+ uint64_t return_to = 18446744073709551059LLU;
12669	12375	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12670	12376	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12671	12377	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12674,18 +12380,18 @@
12674	12380	state.addr = 606163278933917696LLU; // fnfinite__
12675	12381	break;
12676	12382	}
12677		- case 18446744073709551050LLU: // 999999991J'''''''''''''''
	12383	+ case 18446744073709551059LLU: // 999999991S'''''''''''''''
12678	12384	{
12679		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551053LLU : 18446744073709551052LLU;
	12385	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551062LLU : 18446744073709551061LLU;
12680	12386	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12681	12387	break;
12682	12388	}
12683		- case 18446744073709551053LLU: // 999999991M'''''''''''''''
	12389	+ case 18446744073709551062LLU: // 999999991V'''''''''''''''
12684	12390	{
12685		- state.addr = 18446744073709551051LLU; // 999999991K'''''''''''''''
	12391	+ state.addr = 18446744073709551060LLU; // 999999991T'''''''''''''''
12686	12392	break;
12687	12393	}
12688		- case 18446744073709551052LLU: // 999999991L'''''''''''''''
	12394	+ case 18446744073709551061LLU: // 999999991U'''''''''''''''
12689	12395	{
12690	12396	fprintf(stderr, "%s", "function ");
12691	12397	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)));

		@@ -12696,15 +12402,15 @@
12696	12402	fprintf(stderr, "%s\n", "");
12697	12403	exit(-1);
12698	12404	}
12699		- state.addr = 18446744073709551051LLU; // 999999991K'''''''''''''''
	12405	+ state.addr = 18446744073709551060LLU; // 999999991T'''''''''''''''
12700	12406	break;
12701	12407	}
12702		- case 18446744073709551051LLU: // 999999991K'''''''''''''''
	12408	+ case 18446744073709551060LLU: // 999999991T'''''''''''''''
12703	12409	{
12704		- state.addr = 18446744073709551054LLU; // 999999991N'''''''''''''''
	12410	+ state.addr = 18446744073709551063LLU; // 999999991W'''''''''''''''
12705	12411	break;
12706	12412	}
12707		- case 18446744073709551054LLU: // 999999991N'''''''''''''''
	12413	+ case 18446744073709551063LLU: // 999999991W'''''''''''''''
12708	12414	{
12709	12415	{
12710	12416	uint64_t arg = 0;

		@@ -12711,11 +12417,11 @@
12711	12417	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
12712	12418	}
12713	12419	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /safe______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU));
12714		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551049LLU : 18446744073709551048LLU;
	12420	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551058LLU : 18446744073709551057LLU;
12715	12421	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12716	12422	break;
12717	12423	}
12718		- case 18446744073709551049LLU: // 999999991I'''''''''''''''
	12424	+ case 18446744073709551058LLU: // 999999991R'''''''''''''''
12719	12425	{
12720	12426	{
12721	12427	uint64_t arg = 0;

		@@ -12731,7 +12437,7 @@
12731	12437	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12732	12438	}
12733	12439	// ACCUMULATE ARGUMENTS - END
12734		- uint64_t return_to = 18446744073709551044LLU;
	12440	+ uint64_t return_to = 18446744073709551053LLU;
12735	12441	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12736	12442	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12737	12443	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12740,18 +12446,18 @@
12740	12446	state.addr = 606219895113252864LLU; // fnsafe____
12741	12447	break;
12742	12448	}
12743		- case 18446744073709551044LLU: // 999999991D'''''''''''''''
	12449	+ case 18446744073709551053LLU: // 999999991M'''''''''''''''
12744	12450	{
12745		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551047LLU : 18446744073709551046LLU;
	12451	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551056LLU : 18446744073709551055LLU;
12746	12452	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
12747	12453	break;
12748	12454	}
12749		- case 18446744073709551047LLU: // 999999991G'''''''''''''''
	12455	+ case 18446744073709551056LLU: // 999999991P'''''''''''''''
12750	12456	{
12751		- state.addr = 18446744073709551045LLU; // 999999991E'''''''''''''''
	12457	+ state.addr = 18446744073709551054LLU; // 999999991N'''''''''''''''
12752	12458	break;
12753	12459	}
12754		- case 18446744073709551046LLU: // 999999991F'''''''''''''''
	12460	+ case 18446744073709551055LLU: // 999999991O'''''''''''''''
12755	12461	{
12756	12462	fprintf(stderr, "%s", "function ");
12757	12463	printid(stderr, /def_id____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)));

		@@ -12762,15 +12468,15 @@
12762	12468	fprintf(stderr, "%s\n", "");
12763	12469	exit(-1);
12764	12470	}
12765		- state.addr = 18446744073709551045LLU; // 999999991E'''''''''''''''
	12471	+ state.addr = 18446744073709551054LLU; // 999999991N'''''''''''''''
12766	12472	break;
12767	12473	}
12768		- case 18446744073709551045LLU: // 999999991E'''''''''''''''
	12474	+ case 18446744073709551054LLU: // 999999991N'''''''''''''''
12769	12475	{
12770		- state.addr = 18446744073709551048LLU; // 999999991H'''''''''''''''
	12476	+ state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
12771	12477	break;
12772	12478	}
12773		- case 18446744073709551048LLU: // 999999991H'''''''''''''''
	12479	+ case 18446744073709551057LLU: // 999999991Q'''''''''''''''
12774	12480	{
12775	12481	// parameter-reference u64 safe______ goes out of scope
12776	12482	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference safe______ at 6

		@@ -12820,7 +12526,7 @@
12820	12526	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12821	12527	}
12822	12528	// ACCUMULATE ARGUMENTS - END
12823		- uint64_t return_to = 18446744073709551043LLU;
	12529	+ uint64_t return_to = 18446744073709551052LLU;
12824	12530	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
12825	12531	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12826	12532	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12829,7 +12535,7 @@
12829	12535	state.addr = 567600662901349312LLU; // defassert_
12830	12536	break;
12831	12537	}
12832		- case 18446744073709551043LLU: // 999999991C'''''''''''''''
	12538	+ case 18446744073709551052LLU: // 999999991L'''''''''''''''
12833	12539	{
12834	12540
12835	12541	access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 8LLU)) = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 3LLU));

		@@ -12843,10 +12549,10 @@
12843	12549	uint64_t arg = 0;
12844	12550	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
12845	12551	}
12846		- state.addr = 18446744073709551042LLU; // 999999991B'''''''''''''''
	12552	+ state.addr = 18446744073709551051LLU; // 999999991K'''''''''''''''
12847	12553	break;
12848	12554	}
12849		- case 18446744073709551042LLU: // 999999991B'''''''''''''''
	12555	+ case 18446744073709551051LLU: // 999999991K'''''''''''''''
12850	12556	{
12851	12557	if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
12852	12558	{

		@@ -12853,7 +12559,7 @@
12853	12559	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
12854	12560	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
12855	12561	{
12856		- state.addr = 18446744073709551041LLU; // 999999991A'''''''''''''''
	12562	+ state.addr = 18446744073709551050LLU; // 999999991J'''''''''''''''
12857	12563	break;
12858	12564	}
12859	12565	}

		@@ -12886,7 +12592,7 @@
12886	12592	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12887	12593	}
12888	12594	// ACCUMULATE ARGUMENTS - END
12889		- uint64_t return_to = 18446744073709551036LLU;
	12595	+ uint64_t return_to = 18446744073709551045LLU;
12890	12596	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12891	12597	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12892	12598	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12895,7 +12601,7 @@
12895	12601	state.addr = 367395560426147840LLU; // TYPECOPY__
12896	12602	break;
12897	12603	}
12898		- case 18446744073709551036LLU: // 9999999906'''''''''''''''
	12604	+ case 18446744073709551045LLU: // 999999991E'''''''''''''''
12899	12605	{
12900	12606	{
12901	12607	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -12924,7 +12630,7 @@
12924	12630	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12925	12631	}
12926	12632	// ACCUMULATE ARGUMENTS - END
12927		- uint64_t return_to = 18446744073709551035LLU;
	12633	+ uint64_t return_to = 18446744073709551044LLU;
12928	12634	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12929	12635	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12930	12636	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12933,7 +12639,7 @@
12933	12639	state.addr = 552446646280519680LLU; // copyu64___
12934	12640	break;
12935	12641	}
12936		- case 18446744073709551035LLU: // 9999999905'''''''''''''''
	12642	+ case 18446744073709551044LLU: // 999999991D'''''''''''''''
12937	12643	{
12938	12644	{
12939	12645	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -12962,7 +12668,7 @@
12962	12668	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
12963	12669	}
12964	12670	// ACCUMULATE ARGUMENTS - END
12965		- uint64_t return_to = 18446744073709551034LLU;
	12671	+ uint64_t return_to = 18446744073709551043LLU;
12966	12672	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
12967	12673	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12968	12674	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12971,7 +12677,7 @@
12971	12677	state.addr = 552446646280519680LLU; // copyu64___
12972	12678	break;
12973	12679	}
12974		- case 18446744073709551034LLU: // 9999999904'''''''''''''''
	12680	+ case 18446744073709551043LLU: // 999999991C'''''''''''''''
12975	12681	{
12976	12682	{
12977	12683	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -12983,7 +12689,7 @@
12983	12689	}
12984	12690	}
12985	12691	// ACCUMULATE ARGUMENTS - END
12986		- uint64_t return_to = 18446744073709551037LLU;
	12692	+ uint64_t return_to = 18446744073709551046LLU;
12987	12693	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
12988	12694	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
12989	12695	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -12992,12 +12698,12 @@
12992	12698	state.addr = 819859607768530944LLU; // resdest___
12993	12699	break;
12994	12700	}
12995		- case 18446744073709551037LLU: // 9999999907'''''''''''''''
	12701	+ case 18446744073709551046LLU: // 999999991F'''''''''''''''
12996	12702	{
12997		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU)), 8) ? 18446744073709551040LLU : 18446744073709551039LLU;
	12703	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU)), 8) ? 18446744073709551049LLU : 18446744073709551048LLU;
12998	12704	break;
12999	12705	}
13000		- case 18446744073709551040LLU: // 999999991_'''''''''''''''
	12706	+ case 18446744073709551049LLU: // 999999991I'''''''''''''''
13001	12707	{
13002	12708	fprintf(stderr, "%s", "pushing par ");
13003	12709	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -13006,7 +12712,7 @@
13006	12712	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13007	12713	}
13008	12714	// ACCUMULATE ARGUMENTS - END
13009		- uint64_t return_to = 18446744073709551033LLU;
	12715	+ uint64_t return_to = 18446744073709551042LLU;
13010	12716	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13011	12717	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13012	12718	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13015,7 +12721,7 @@
13015	12721	state.addr = 819847183518272384LLU; // reportres_
13016	12722	break;
13017	12723	}
13018		- case 18446744073709551033LLU: // 9999999903'''''''''''''''
	12724	+ case 18446744073709551042LLU: // 999999991B'''''''''''''''
13019	12725	{
13020	12726	fprintf(stderr, "%s", "\n");
13021	12727	{

		@@ -13029,7 +12735,7 @@
13029	12735	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13030	12736	}
13031	12737	// ACCUMULATE ARGUMENTS - END
13032		- uint64_t return_to = 18446744073709551032LLU;
	12738	+ uint64_t return_to = 18446744073709551041LLU;
13033	12739	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13034	12740	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13035	12741	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13038,26 +12744,26 @@
13038	12744	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
13039	12745	break;
13040	12746	}
13041		- case 18446744073709551032LLU: // 9999999902'''''''''''''''
	12747	+ case 18446744073709551041LLU: // 999999991A'''''''''''''''
13042	12748	{
13043	12749	// parameter resdest___ new_______ goes out of scope
13044		- state.addr = 18446744073709551038LLU; // 9999999908'''''''''''''''
	12750	+ state.addr = 18446744073709551047LLU; // 999999991G'''''''''''''''
13045	12751	break;
13046	12752	}
13047		- case 18446744073709551039LLU: // 9999999909'''''''''''''''
	12753	+ case 18446744073709551048LLU: // 999999991H'''''''''''''''
13048	12754	{
13049		- state.addr = 18446744073709551038LLU; // 9999999908'''''''''''''''
	12755	+ state.addr = 18446744073709551047LLU; // 999999991G'''''''''''''''
13050	12756	break;
13051	12757	}
13052		- case 18446744073709551038LLU: // 9999999908'''''''''''''''
	12758	+ case 18446744073709551047LLU: // 999999991G'''''''''''''''
13053	12759	{
13054	12760	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
13055	12761	// parameter-reference resdest___ par_______ goes out of scope
13056	12762	// parameter-reference function__ fn________ goes out of scope
13057		- state.addr = 18446744073709551042LLU; // 999999991B'''''''''''''''
	12763	+ state.addr = 18446744073709551051LLU; // 999999991K'''''''''''''''
13058	12764	break;
13059	12765	}
13060		- case 18446744073709551041LLU: // 999999991A'''''''''''''''
	12766	+ case 18446744073709551050LLU: // 999999991J'''''''''''''''
13061	12767	{
13062	12768	{
13063	12769	uint64_t arg = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 1LLU));

		@@ -13067,10 +12773,10 @@
13067	12773	uint64_t arg = 0;
13068	12774	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
13069	12775	}
13070		- state.addr = 18446744073709551031LLU; // 9999999901'''''''''''''''
	12776	+ state.addr = 18446744073709551040LLU; // 999999991_'''''''''''''''
13071	12777	break;
13072	12778	}
13073		- case 18446744073709551031LLU: // 9999999901'''''''''''''''
	12779	+ case 18446744073709551040LLU: // 999999991_'''''''''''''''
13074	12780	{
13075	12781	if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
13076	12782	{

		@@ -13077,7 +12783,7 @@
13077	12783	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
13078	12784	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
13079	12785	{
13080		- state.addr = 18446744073709551030LLU; // 9999999900'''''''''''''''
	12786	+ state.addr = 18446744073709551039LLU; // 9999999909'''''''''''''''
13081	12787	break;
13082	12788	}
13083	12789	}

		@@ -13110,7 +12816,7 @@
13110	12816	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13111	12817	}
13112	12818	// ACCUMULATE ARGUMENTS - END
13113		- uint64_t return_to = 18446744073709551025LLU;
	12819	+ uint64_t return_to = 18446744073709551034LLU;
13114	12820	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13115	12821	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13116	12822	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13119,7 +12825,7 @@
13119	12825	state.addr = 367395560426147840LLU; // TYPECOPY__
13120	12826	break;
13121	12827	}
13122		- case 18446744073709551025LLU: // 999999990v'''''''''''''''
	12828	+ case 18446744073709551034LLU: // 9999999904'''''''''''''''
13123	12829	{
13124	12830	{
13125	12831	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -13148,7 +12854,7 @@
13148	12854	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13149	12855	}
13150	12856	// ACCUMULATE ARGUMENTS - END
13151		- uint64_t return_to = 18446744073709551024LLU;
	12857	+ uint64_t return_to = 18446744073709551033LLU;
13152	12858	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13153	12859	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13154	12860	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13157,7 +12863,7 @@
13157	12863	state.addr = 552446646280519680LLU; // copyu64___
13158	12864	break;
13159	12865	}
13160		- case 18446744073709551024LLU: // 999999990u'''''''''''''''
	12866	+ case 18446744073709551033LLU: // 9999999903'''''''''''''''
13161	12867	{
13162	12868	{
13163	12869	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -13186,7 +12892,7 @@
13186	12892	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13187	12893	}
13188	12894	// ACCUMULATE ARGUMENTS - END
13189		- uint64_t return_to = 18446744073709551023LLU;
	12895	+ uint64_t return_to = 18446744073709551032LLU;
13190	12896	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13191	12897	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13192	12898	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13195,7 +12901,7 @@
13195	12901	state.addr = 58555672873677120LLU; // CPBALANCE_
13196	12902	break;
13197	12903	}
13198		- case 18446744073709551023LLU: // 999999990t'''''''''''''''
	12904	+ case 18446744073709551032LLU: // 9999999902'''''''''''''''
13199	12905	{
13200	12906	{
13201	12907	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -13224,7 +12930,7 @@
13224	12930	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13225	12931	}
13226	12932	// ACCUMULATE ARGUMENTS - END
13227		- uint64_t return_to = 18446744073709551022LLU;
	12933	+ uint64_t return_to = 18446744073709551031LLU;
13228	12934	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13229	12935	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13230	12936	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13233,7 +12939,7 @@
13233	12939	state.addr = 552446646280519680LLU; // copyu64___
13234	12940	break;
13235	12941	}
13236		- case 18446744073709551022LLU: // 999999990s'''''''''''''''
	12942	+ case 18446744073709551031LLU: // 9999999901'''''''''''''''
13237	12943	{
13238	12944	{
13239	12945	uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 15*/;

		@@ -13245,7 +12951,7 @@
13245	12951	}
13246	12952	}
13247	12953	// ACCUMULATE ARGUMENTS - END
13248		- uint64_t return_to = 18446744073709551026LLU;
	12954	+ uint64_t return_to = 18446744073709551035LLU;
13249	12955	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
13250	12956	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13251	12957	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13254,12 +12960,12 @@
13254	12960	state.addr = 782700512565788672LLU; // pardef____
13255	12961	break;
13256	12962	}
13257		- case 18446744073709551026LLU: // 999999990w'''''''''''''''
	12963	+ case 18446744073709551035LLU: // 9999999905'''''''''''''''
13258	12964	{
13259		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU)), 11) ? 18446744073709551029LLU : 18446744073709551028LLU;
	12965	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU)), 11) ? 18446744073709551038LLU : 18446744073709551037LLU;
13260	12966	break;
13261	12967	}
13262		- case 18446744073709551029LLU: // 999999990z'''''''''''''''
	12968	+ case 18446744073709551038LLU: // 9999999908'''''''''''''''
13263	12969	{
13264	12970	fprintf(stderr, "%s", "[defunpack] pushing par ");
13265	12971	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -13268,7 +12974,7 @@
13268	12974	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13269	12975	}
13270	12976	// ACCUMULATE ARGUMENTS - END
13271		- uint64_t return_to = 18446744073709551021LLU;
	12977	+ uint64_t return_to = 18446744073709551030LLU;
13272	12978	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13273	12979	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13274	12980	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13277,7 +12983,7 @@
13277	12983	state.addr = 819847183518878432LLU; // reporttype
13278	12984	break;
13279	12985	}
13280		- case 18446744073709551021LLU: // 999999990r'''''''''''''''
	12986	+ case 18446744073709551030LLU: // 9999999900'''''''''''''''
13281	12987	{
13282	12988	fprintf(stderr, "%s", "\n");
13283	12989	{

		@@ -13291,35 +12997,35 @@
13291	12997	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13292	12998	}
13293	12999	// ACCUMULATE ARGUMENTS - END
13294		- uint64_t return_to = 18446744073709551020LLU;
	13000	+ uint64_t return_to = 18446744073709551029LLU;
13295	13001	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13296	13002	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13297	13003	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
13298	13004	heap.data[0].elem1 = heap.data[0].elem0;
13299	13005	heap.data[0].elem0 = restore;
13300		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	13006	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
13301	13007	break;
13302	13008	}
13303		- case 18446744073709551020LLU: // 999999990q'''''''''''''''
	13009	+ case 18446744073709551029LLU: // 999999990z'''''''''''''''
13304	13010	{
13305	13011	// parameter pardef____ new_______ goes out of scope
13306		- state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
	13012	+ state.addr = 18446744073709551036LLU; // 9999999906'''''''''''''''
13307	13013	break;
13308	13014	}
13309		- case 18446744073709551028LLU: // 999999990y'''''''''''''''
	13015	+ case 18446744073709551037LLU: // 9999999907'''''''''''''''
13310	13016	{
13311		- state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
	13017	+ state.addr = 18446744073709551036LLU; // 9999999906'''''''''''''''
13312	13018	break;
13313	13019	}
13314		- case 18446744073709551027LLU: // 999999990x'''''''''''''''
	13020	+ case 18446744073709551036LLU: // 9999999906'''''''''''''''
13315	13021	{
13316	13022	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
13317	13023	// parameter-reference pardef____ par_______ goes out of scope
13318	13024	// parameter-reference function__ fn________ goes out of scope
13319		- state.addr = 18446744073709551031LLU; // 9999999901'''''''''''''''
	13025	+ state.addr = 18446744073709551040LLU; // 999999991_'''''''''''''''
13320	13026	break;
13321	13027	}
13322		- case 18446744073709551030LLU: // 9999999900'''''''''''''''
	13028	+ case 18446744073709551039LLU: // 9999999909'''''''''''''''
13323	13029	{
13324	13030	// parameter-reference u64 sizeonheap goes out of scope
13325	13031	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 10

		@@ -13425,10 +13131,10 @@
13425	13131	uint64_t arg = 0;
13426	13132	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
13427	13133	}
13428		- state.addr = 18446744073709551018LLU; // 999999990o'''''''''''''''
	13134	+ state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
13429	13135	break;
13430	13136	}
13431		- case 18446744073709551018LLU: // 999999990o'''''''''''''''
	13137	+ case 18446744073709551027LLU: // 999999990x'''''''''''''''
13432	13138	{
13433	13139	if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU))
13434	13140	{

		@@ -13435,7 +13141,7 @@
13435	13141	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
13436	13142	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
13437	13143	{
13438		- state.addr = 18446744073709551017LLU; // 999999990n'''''''''''''''
	13144	+ state.addr = 18446744073709551026LLU; // 999999990w'''''''''''''''
13439	13145	break;
13440	13146	}
13441	13147	}

		@@ -13468,7 +13174,7 @@
13468	13174	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13469	13175	}
13470	13176	// ACCUMULATE ARGUMENTS - END
13471		- uint64_t return_to = 18446744073709551012LLU;
	13177	+ uint64_t return_to = 18446744073709551021LLU;
13472	13178	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13473	13179	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13474	13180	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13477,7 +13183,7 @@
13477	13183	state.addr = 367395560426147840LLU; // TYPECOPY__
13478	13184	break;
13479	13185	}
13480		- case 18446744073709551012LLU: // 999999990i'''''''''''''''
	13186	+ case 18446744073709551021LLU: // 999999990r'''''''''''''''
13481	13187	{
13482	13188	{
13483	13189	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13506,7 +13212,7 @@
13506	13212	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13507	13213	}
13508	13214	// ACCUMULATE ARGUMENTS - END
13509		- uint64_t return_to = 18446744073709551011LLU;
	13215	+ uint64_t return_to = 18446744073709551020LLU;
13510	13216	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13511	13217	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13512	13218	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13515,7 +13221,7 @@
13515	13221	state.addr = 552446646280519680LLU; // copyu64___
13516	13222	break;
13517	13223	}
13518		- case 18446744073709551011LLU: // 999999990h'''''''''''''''
	13224	+ case 18446744073709551020LLU: // 999999990q'''''''''''''''
13519	13225	{
13520	13226	{
13521	13227	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13544,7 +13250,7 @@
13544	13250	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13545	13251	}
13546	13252	// ACCUMULATE ARGUMENTS - END
13547		- uint64_t return_to = 18446744073709551010LLU;
	13253	+ uint64_t return_to = 18446744073709551019LLU;
13548	13254	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13549	13255	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13550	13256	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13553,7 +13259,7 @@
13553	13259	state.addr = 58555672873677120LLU; // CPBALANCE_
13554	13260	break;
13555	13261	}
13556		- case 18446744073709551010LLU: // 999999990g'''''''''''''''
	13262	+ case 18446744073709551019LLU: // 999999990p'''''''''''''''
13557	13263	{
13558	13264	{
13559	13265	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13582,7 +13288,7 @@
13582	13288	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13583	13289	}
13584	13290	// ACCUMULATE ARGUMENTS - END
13585		- uint64_t return_to = 18446744073709551009LLU;
	13291	+ uint64_t return_to = 18446744073709551018LLU;
13586	13292	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13587	13293	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13588	13294	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13591,7 +13297,7 @@
13591	13297	state.addr = 552446646280519680LLU; // copyu64___
13592	13298	break;
13593	13299	}
13594		- case 18446744073709551009LLU: // 999999990f'''''''''''''''
	13300	+ case 18446744073709551018LLU: // 999999990o'''''''''''''''
13595	13301	{
13596	13302	{
13597	13303	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13603,7 +13309,7 @@
13603	13309	}
13604	13310	}
13605	13311	// ACCUMULATE ARGUMENTS - END
13606		- uint64_t return_to = 18446744073709551013LLU;
	13312	+ uint64_t return_to = 18446744073709551022LLU;
13607	13313	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
13608	13314	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13609	13315	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13612,12 +13318,12 @@
13612	13318	state.addr = 782700512565788672LLU; // pardef____
13613	13319	break;
13614	13320	}
13615		- case 18446744073709551013LLU: // 999999990j'''''''''''''''
	13321	+ case 18446744073709551022LLU: // 999999990s'''''''''''''''
13616	13322	{
13617		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 4LLU)), 11) ? 18446744073709551016LLU : 18446744073709551015LLU;
	13323	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 4LLU)), 11) ? 18446744073709551025LLU : 18446744073709551024LLU;
13618	13324	break;
13619	13325	}
13620		- case 18446744073709551016LLU: // 999999990m'''''''''''''''
	13326	+ case 18446744073709551025LLU: // 999999990v'''''''''''''''
13621	13327	{
13622	13328	fprintf(stderr, "%s", "pushing par ");
13623	13329	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -13626,7 +13332,7 @@
13626	13332	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13627	13333	}
13628	13334	// ACCUMULATE ARGUMENTS - END
13629		- uint64_t return_to = 18446744073709551008LLU;
	13335	+ uint64_t return_to = 18446744073709551017LLU;
13630	13336	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13631	13337	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13632	13338	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13635,7 +13341,7 @@
13635	13341	state.addr = 819847183518878432LLU; // reporttype
13636	13342	break;
13637	13343	}
13638		- case 18446744073709551008LLU: // 999999990e'''''''''''''''
	13344	+ case 18446744073709551017LLU: // 999999990n'''''''''''''''
13639	13345	{
13640	13346	fprintf(stderr, "%s", "\n");
13641	13347	{

		@@ -13649,35 +13355,35 @@
13649	13355	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13650	13356	}
13651	13357	// ACCUMULATE ARGUMENTS - END
13652		- uint64_t return_to = 18446744073709551007LLU;
	13358	+ uint64_t return_to = 18446744073709551016LLU;
13653	13359	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13654	13360	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13655	13361	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
13656	13362	heap.data[0].elem1 = heap.data[0].elem0;
13657	13363	heap.data[0].elem0 = restore;
13658		- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
	13364	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
13659	13365	break;
13660	13366	}
13661		- case 18446744073709551007LLU: // 999999990d'''''''''''''''
	13367	+ case 18446744073709551016LLU: // 999999990m'''''''''''''''
13662	13368	{
13663	13369	// parameter pardef____ new_______ goes out of scope
13664		- state.addr = 18446744073709551014LLU; // 999999990k'''''''''''''''
	13370	+ state.addr = 18446744073709551023LLU; // 999999990t'''''''''''''''
13665	13371	break;
13666	13372	}
13667		- case 18446744073709551015LLU: // 999999990l'''''''''''''''
	13373	+ case 18446744073709551024LLU: // 999999990u'''''''''''''''
13668	13374	{
13669		- state.addr = 18446744073709551014LLU; // 999999990k'''''''''''''''
	13375	+ state.addr = 18446744073709551023LLU; // 999999990t'''''''''''''''
13670	13376	break;
13671	13377	}
13672		- case 18446744073709551014LLU: // 999999990k'''''''''''''''
	13378	+ case 18446744073709551023LLU: // 999999990t'''''''''''''''
13673	13379	{
13674	13380	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
13675	13381	// parameter-reference pardef____ par_______ goes out of scope
13676	13382	// parameter-reference list<pardef____> defpars1__ goes out of scope
13677		- state.addr = 18446744073709551018LLU; // 999999990o'''''''''''''''
	13383	+ state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
13678	13384	break;
13679	13385	}
13680		- case 18446744073709551017LLU: // 999999990n'''''''''''''''
	13386	+ case 18446744073709551026LLU: // 999999990w'''''''''''''''
13681	13387	{
13682	13388	{
13683	13389	uint64_t arg = /respars1__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 10LLU));

		@@ -13687,10 +13393,10 @@
13687	13393	uint64_t arg = 0;
13688	13394	LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/address of current closure/, &arg);
13689	13395	}
13690		- state.addr = 18446744073709551006LLU; // 999999990c'''''''''''''''
	13396	+ state.addr = 18446744073709551015LLU; // 999999990l'''''''''''''''
13691	13397	break;
13692	13398	}
13693		- case 18446744073709551006LLU: // 999999990c'''''''''''''''
	13399	+ case 18446744073709551015LLU: // 999999990l'''''''''''''''
13694	13400	{
13695	13401	if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU))
13696	13402	{

		@@ -13697,7 +13403,7 @@
13697	13403	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
13698	13404	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
13699	13405	{
13700		- state.addr = 18446744073709551005LLU; // 999999990b'''''''''''''''
	13406	+ state.addr = 18446744073709551014LLU; // 999999990k'''''''''''''''
13701	13407	break;
13702	13408	}
13703	13409	}

		@@ -13730,7 +13436,7 @@
13730	13436	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13731	13437	}
13732	13438	// ACCUMULATE ARGUMENTS - END
13733		- uint64_t return_to = 18446744073709551000LLU;
	13439	+ uint64_t return_to = 18446744073709551009LLU;
13734	13440	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13735	13441	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13736	13442	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13739,7 +13445,7 @@
13739	13445	state.addr = 367395560426147840LLU; // TYPECOPY__
13740	13446	break;
13741	13447	}
13742		- case 18446744073709551000LLU: // 999999990X'''''''''''''''
	13448	+ case 18446744073709551009LLU: // 999999990f'''''''''''''''
13743	13449	{
13744	13450	{
13745	13451	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13768,7 +13474,7 @@
13768	13474	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13769	13475	}
13770	13476	// ACCUMULATE ARGUMENTS - END
13771		- uint64_t return_to = 18446744073709550999LLU;
	13477	+ uint64_t return_to = 18446744073709551008LLU;
13772	13478	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13773	13479	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13774	13480	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13777,7 +13483,7 @@
13777	13483	state.addr = 552446646280519680LLU; // copyu64___
13778	13484	break;
13779	13485	}
13780		- case 18446744073709550999LLU: // 999999990W'''''''''''''''
	13486	+ case 18446744073709551008LLU: // 999999990e'''''''''''''''
13781	13487	{
13782	13488	{
13783	13489	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13806,7 +13512,7 @@
13806	13512	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13807	13513	}
13808	13514	// ACCUMULATE ARGUMENTS - END
13809		- uint64_t return_to = 18446744073709550998LLU;
	13515	+ uint64_t return_to = 18446744073709551007LLU;
13810	13516	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
13811	13517	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13812	13518	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13815,7 +13521,7 @@
13815	13521	state.addr = 552446646280519680LLU; // copyu64___
13816	13522	break;
13817	13523	}
13818		- case 18446744073709550998LLU: // 999999990V'''''''''''''''
	13524	+ case 18446744073709551007LLU: // 999999990d'''''''''''''''
13819	13525	{
13820	13526	{
13821	13527	uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 22*/;

		@@ -13827,7 +13533,7 @@
13827	13533	}
13828	13534	}
13829	13535	// ACCUMULATE ARGUMENTS - END
13830		- uint64_t return_to = 18446744073709551001LLU;
	13536	+ uint64_t return_to = 18446744073709551010LLU;
13831	13537	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
13832	13538	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13833	13539	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13836,12 +13542,12 @@
13836	13542	state.addr = 819859607768530944LLU; // resdest___
13837	13543	break;
13838	13544	}
13839		- case 18446744073709551001LLU: // 999999990Y'''''''''''''''
	13545	+ case 18446744073709551010LLU: // 999999990g'''''''''''''''
13840	13546	{
13841		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 3LLU)), 8) ? 18446744073709551004LLU : 18446744073709551003LLU;
	13547	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 3LLU)), 8) ? 18446744073709551013LLU : 18446744073709551012LLU;
13842	13548	break;
13843	13549	}
13844		- case 18446744073709551004LLU: // 999999990a'''''''''''''''
	13550	+ case 18446744073709551013LLU: // 999999990j'''''''''''''''
13845	13551	{
13846	13552	fprintf(stderr, "%s", "pushing par ");
13847	13553	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -13850,7 +13556,7 @@
13850	13556	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13851	13557	}
13852	13558	// ACCUMULATE ARGUMENTS - END
13853		- uint64_t return_to = 18446744073709550997LLU;
	13559	+ uint64_t return_to = 18446744073709551006LLU;
13854	13560	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13855	13561	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13856	13562	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13859,7 +13565,7 @@
13859	13565	state.addr = 819847183518272384LLU; // reportres_
13860	13566	break;
13861	13567	}
13862		- case 18446744073709550997LLU: // 999999990U'''''''''''''''
	13568	+ case 18446744073709551006LLU: // 999999990c'''''''''''''''
13863	13569	{
13864	13570	fprintf(stderr, "%s", "\n");
13865	13571	{

		@@ -13873,7 +13579,7 @@
13873	13579	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
13874	13580	}
13875	13581	// ACCUMULATE ARGUMENTS - END
13876		- uint64_t return_to = 18446744073709550996LLU;
	13582	+ uint64_t return_to = 18446744073709551005LLU;
13877	13583	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
13878	13584	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
13879	13585	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -13882,26 +13588,26 @@
13882	13588	state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
13883	13589	break;
13884	13590	}
13885		- case 18446744073709550996LLU: // 999999990T'''''''''''''''
	13591	+ case 18446744073709551005LLU: // 999999990b'''''''''''''''
13886	13592	{
13887	13593	// parameter resdest___ new_______ goes out of scope
13888		- state.addr = 18446744073709551002LLU; // 999999990Z'''''''''''''''
	13594	+ state.addr = 18446744073709551011LLU; // 999999990h'''''''''''''''
13889	13595	break;
13890	13596	}
13891		- case 18446744073709551003LLU: // 999999990$'''''''''''''''
	13597	+ case 18446744073709551012LLU: // 999999990i'''''''''''''''
13892	13598	{
13893		- state.addr = 18446744073709551002LLU; // 999999990Z'''''''''''''''
	13599	+ state.addr = 18446744073709551011LLU; // 999999990h'''''''''''''''
13894	13600	break;
13895	13601	}
13896		- case 18446744073709551002LLU: // 999999990Z'''''''''''''''
	13602	+ case 18446744073709551011LLU: // 999999990h'''''''''''''''
13897	13603	{
13898	13604	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
13899	13605	// parameter-reference resdest___ par_______ goes out of scope
13900	13606	// parameter-reference list<resdest___> respars1__ goes out of scope
13901		- state.addr = 18446744073709551006LLU; // 999999990c'''''''''''''''
	13607	+ state.addr = 18446744073709551015LLU; // 999999990l'''''''''''''''
13902	13608	break;
13903	13609	}
13904		- case 18446744073709551005LLU: // 999999990b'''''''''''''''
	13610	+ case 18446744073709551014LLU: // 999999990k'''''''''''''''
13905	13611	{
13906	13612	// parameter-reference u64 safe1_____ goes out of scope
13907	13613	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference safe1_____ at 17

		@@ -13960,10 +13666,10 @@
13960	13666	uint64_t arg = 0;
13961	13667	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
13962	13668	}
13963		- state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
	13669	+ state.addr = 18446744073709551004LLU; // 999999990a'''''''''''''''
13964	13670	break;
13965	13671	}
13966		- case 18446744073709550995LLU: // 999999990S'''''''''''''''
	13672	+ case 18446744073709551004LLU: // 999999990a'''''''''''''''
13967	13673	{
13968	13674	if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU))
13969	13675	{

		@@ -13970,7 +13676,7 @@
13970	13676	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
13971	13677	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
13972	13678	{
13973		- state.addr = 18446744073709550994LLU; // 999999990R'''''''''''''''
	13679	+ state.addr = 18446744073709551003LLU; // 999999990$'''''''''''''''
13974	13680	break;
13975	13681	}
13976	13682	}

		@@ -13981,11 +13687,11 @@
13981	13687	LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
13982	13688	}
13983	13689	LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 14LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 0LLU));
13984		- state.addr = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709550993LLU : 18446744073709550992LLU;
	13690	+ state.addr = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709551002LLU : 18446744073709551001LLU;
13985	13691	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 14
13986	13692	break;
13987	13693	}
13988		- case 18446744073709550993LLU: // 999999990Q'''''''''''''''
	13694	+ case 18446744073709551002LLU: // 999999990Z'''''''''''''''
13989	13695	{
13990	13696
13991	13697	*LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = 0;

		@@ -14031,7 +13737,7 @@
14031	13737	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14032	13738	}
14033	13739	// ACCUMULATE ARGUMENTS - END
14034		- uint64_t return_to = 18446744073709550991LLU;
	13740	+ uint64_t return_to = 18446744073709551000LLU;
14035	13741	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0));
14036	13742	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14037	13743	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14040,19 +13746,19 @@
14040	13746	state.addr = 567602031870732672LLU; // defunpack_
14041	13747	break;
14042	13748	}
14043		- case 18446744073709550991LLU: // 999999990O'''''''''''''''
	13749	+ case 18446744073709551000LLU: // 999999990X'''''''''''''''
14044	13750	{
14045		- state.addr = 18446744073709550992LLU; // 999999990P'''''''''''''''
	13751	+ state.addr = 18446744073709551001LLU; // 999999990Y'''''''''''''''
14046	13752	break;
14047	13753	}
14048		- case 18446744073709550992LLU: // 999999990P'''''''''''''''
	13754	+ case 18446744073709551001LLU: // 999999990Y'''''''''''''''
14049	13755	{
14050	13756	// parameter-reference defidfn___ elem______ goes out of scope
14051	13757	// parameter-reference list<defidfn___> fndefs____ goes out of scope
14052		- state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
	13758	+ state.addr = 18446744073709551004LLU; // 999999990a'''''''''''''''
14053	13759	break;
14054	13760	}
14055		- case 18446744073709550994LLU: // 999999990R'''''''''''''''
	13761	+ case 18446744073709551003LLU: // 999999990$'''''''''''''''
14056	13762	{
14057	13763	{
14058	13764	uint64_t arg = 0;

		@@ -14059,11 +13765,11 @@
14059	13765	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
14060	13766	}
14061	13767	LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = /notfound__/LOCAL_ACCESS(heap.data, 12LLU, 10LLU);
14062		- state.addr = *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709550990LLU : 18446744073709550989LLU;
	13768	+ state.addr = *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709550999LLU : 18446744073709550998LLU;
14063	13769	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
14064	13770	break;
14065	13771	}
14066		- case 18446744073709550990LLU: // 999999990N'''''''''''''''
	13772	+ case 18446744073709550999LLU: // 999999990W'''''''''''''''
14067	13773	{
14068	13774	// ACCUMULATE ARGUMENTS - BEGIN
14069	13775	{

		@@ -14075,7 +13781,7 @@
14075	13781	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14076	13782	}
14077	13783	// ACCUMULATE ARGUMENTS - END
14078		- uint64_t return_to = 18446744073709550988LLU;
	13784	+ uint64_t return_to = 18446744073709550997LLU;
14079	13785	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14080	13786	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14081	13787	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14084,7 +13790,7 @@
14084	13790	state.addr = 819847183514601582LLU; // reportdefs
14085	13791	break;
14086	13792	}
14087		- case 18446744073709550988LLU: // 999999990L'''''''''''''''
	13793	+ case 18446744073709550997LLU: // 999999990U'''''''''''''''
14088	13794	{
14089	13795	// ACCUMULATE ARGUMENTS - BEGIN
14090	13796	{

		@@ -14092,7 +13798,7 @@
14092	13798	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14093	13799	}
14094	13800	// ACCUMULATE ARGUMENTS - END
14095		- uint64_t return_to = 18446744073709550987LLU;
	13801	+ uint64_t return_to = 18446744073709550996LLU;
14096	13802	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14097	13803	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14098	13804	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14101,7 +13807,7 @@
14101	13807	state.addr = 819847183515949359LLU; // reportinit
14102	13808	break;
14103	13809	}
14104		- case 18446744073709550987LLU: // 999999990K'''''''''''''''
	13810	+ case 18446744073709550996LLU: // 999999990T'''''''''''''''
14105	13811	{
14106	13812	fprintf(stderr, "%s", "no such function ");
14107	13813	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 11LLU, 2LLU)));

		@@ -14109,10 +13815,10 @@
14109	13815	fprintf(stderr, "%s\n", "");
14110	13816	exit(-1);
14111	13817	}
14112		- state.addr = 18446744073709550989LLU; // 999999990M'''''''''''''''
	13818	+ state.addr = 18446744073709550998LLU; // 999999990V'''''''''''''''
14113	13819	break;
14114	13820	}
14115		- case 18446744073709550989LLU: // 999999990M'''''''''''''''
	13821	+ case 18446744073709550998LLU: // 999999990V'''''''''''''''
14116	13822	{
14117	13823	// variable u64 notfound__ goes out of scope
14118	13824	// emitted destructur for type u64

		@@ -14160,10 +13866,10 @@
14160	13866	uint64_t arg = 0;
14161	13867	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
14162	13868	}
14163		- state.addr = 18446744073709550986LLU; // 999999990J'''''''''''''''
	13869	+ state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
14164	13870	break;
14165	13871	}
14166		- case 18446744073709550986LLU: // 999999990J'''''''''''''''
	13872	+ case 18446744073709550995LLU: // 999999990S'''''''''''''''
14167	13873	{
14168	13874	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
14169	13875	{

		@@ -14170,7 +13876,7 @@
14170	13876	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14171	13877	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14172	13878	{
14173		- state.addr = 18446744073709550985LLU; // 999999990I'''''''''''''''
	13879	+ state.addr = 18446744073709550994LLU; // 999999990R'''''''''''''''
14174	13880	break;
14175	13881	}
14176	13882	}

		@@ -14181,11 +13887,11 @@
14181	13887	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14182	13888	}
14183	13889	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU));
14184		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550984LLU : 18446744073709550983LLU;
	13890	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550993LLU : 18446744073709550992LLU;
14185	13891	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14186	13892	break;
14187	13893	}
14188		- case 18446744073709550984LLU: // 999999990H'''''''''''''''
	13894	+ case 18446744073709550993LLU: // 999999990Q'''''''''''''''
14189	13895	{
14190	13896
14191	13897	*LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0;

		@@ -14203,7 +13909,7 @@
14203	13909	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14204	13910	}
14205	13911	// ACCUMULATE ARGUMENTS - END
14206		- uint64_t return_to = 18446744073709550982LLU;
	13912	+ uint64_t return_to = 18446744073709550991LLU;
14207	13913	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
14208	13914	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14209	13915	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14212,19 +13918,19 @@
14212	13918	state.addr = 606150499514712064LLU; // fncopy____
14213	13919	break;
14214	13920	}
14215		- case 18446744073709550982LLU: // 999999990F'''''''''''''''
	13921	+ case 18446744073709550991LLU: // 999999990O'''''''''''''''
14216	13922	{
14217		- state.addr = 18446744073709550983LLU; // 999999990G'''''''''''''''
	13923	+ state.addr = 18446744073709550992LLU; // 999999990P'''''''''''''''
14218	13924	break;
14219	13925	}
14220		- case 18446744073709550983LLU: // 999999990G'''''''''''''''
	13926	+ case 18446744073709550992LLU: // 999999990P'''''''''''''''
14221	13927	{
14222	13928	// parameter-reference defidfn___ elem______ goes out of scope
14223	13929	// parameter-reference list<defidfn___> fndefs____ goes out of scope
14224		- state.addr = 18446744073709550986LLU; // 999999990J'''''''''''''''
	13930	+ state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
14225	13931	break;
14226	13932	}
14227		- case 18446744073709550985LLU: // 999999990I'''''''''''''''
	13933	+ case 18446744073709550994LLU: // 999999990R'''''''''''''''
14228	13934	{
14229	13935	{
14230	13936	uint64_t arg = 0;

		@@ -14231,11 +13937,11 @@
14231	13937	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
14232	13938	}
14233	13939	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /notfound__/LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
14234		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550981LLU : 18446744073709550980LLU;
	13940	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550990LLU : 18446744073709550989LLU;
14235	13941	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14236	13942	break;
14237	13943	}
14238		- case 18446744073709550981LLU: // 999999990E'''''''''''''''
	13944	+ case 18446744073709550990LLU: // 999999990N'''''''''''''''
14239	13945	{
14240	13946	// ACCUMULATE ARGUMENTS - BEGIN
14241	13947	{

		@@ -14247,7 +13953,7 @@
14247	13953	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14248	13954	}
14249	13955	// ACCUMULATE ARGUMENTS - END
14250		- uint64_t return_to = 18446744073709550979LLU;
	13956	+ uint64_t return_to = 18446744073709550988LLU;
14251	13957	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14252	13958	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14253	13959	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14256,7 +13962,7 @@
14256	13962	state.addr = 819847183514601582LLU; // reportdefs
14257	13963	break;
14258	13964	}
14259		- case 18446744073709550979LLU: // 999999990C'''''''''''''''
	13965	+ case 18446744073709550988LLU: // 999999990L'''''''''''''''
14260	13966	{
14261	13967	// ACCUMULATE ARGUMENTS - BEGIN
14262	13968	{

		@@ -14264,7 +13970,7 @@
14264	13970	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14265	13971	}
14266	13972	// ACCUMULATE ARGUMENTS - END
14267		- uint64_t return_to = 18446744073709550978LLU;
	13973	+ uint64_t return_to = 18446744073709550987LLU;
14268	13974	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14269	13975	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14270	13976	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14273,7 +13979,7 @@
14273	13979	state.addr = 819847183515949359LLU; // reportinit
14274	13980	break;
14275	13981	}
14276		- case 18446744073709550978LLU: // 999999990B'''''''''''''''
	13982	+ case 18446744073709550987LLU: // 999999990K'''''''''''''''
14277	13983	{
14278	13984	fprintf(stderr, "%s", "no such function ");
14279	13985	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 3LLU)));

		@@ -14281,10 +13987,10 @@
14281	13987	fprintf(stderr, "%s\n", "");
14282	13988	exit(-1);
14283	13989	}
14284		- state.addr = 18446744073709550980LLU; // 999999990D'''''''''''''''
	13990	+ state.addr = 18446744073709550989LLU; // 999999990M'''''''''''''''
14285	13991	break;
14286	13992	}
14287		- case 18446744073709550980LLU: // 999999990D'''''''''''''''
	13993	+ case 18446744073709550989LLU: // 999999990M'''''''''''''''
14288	13994	{
14289	13995	// variable u64 notfound__ goes out of scope
14290	13996	// emitted destructur for type u64

		@@ -14320,10 +14026,10 @@
14320	14026	uint64_t arg = 0;
14321	14027	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
14322	14028	}
14323		- state.addr = 18446744073709550977LLU; // 999999990A'''''''''''''''
	14029	+ state.addr = 18446744073709550986LLU; // 999999990J'''''''''''''''
14324	14030	break;
14325	14031	}
14326		- case 18446744073709550977LLU: // 999999990A'''''''''''''''
	14032	+ case 18446744073709550986LLU: // 999999990J'''''''''''''''
14327	14033	{
14328	14034	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
14329	14035	{

		@@ -14330,7 +14036,7 @@
14330	14036	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14331	14037	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14332	14038	{
14333		- state.addr = 18446744073709550976LLU; // 999999990_'''''''''''''''
	14039	+ state.addr = 18446744073709550985LLU; // 999999990I'''''''''''''''
14334	14040	break;
14335	14041	}
14336	14042	}

		@@ -14341,11 +14047,11 @@
14341	14047	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14342	14048	}
14343	14049	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /notfound__/LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
14344		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550975LLU : 18446744073709550974LLU;
	14050	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550984LLU : 18446744073709550983LLU;
14345	14051	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14346	14052	break;
14347	14053	}
14348		- case 18446744073709550975LLU: // 99999999z9'''''''''''''''
	14054	+ case 18446744073709550984LLU: // 999999990H'''''''''''''''
14349	14055	{
14350	14056	{
14351	14057	uint64_t arg = 0;

		@@ -14352,11 +14058,11 @@
14352	14058	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14353	14059	}
14354	14060	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU));
14355		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550973LLU : 18446744073709550972LLU;
	14061	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550982LLU : 18446744073709550981LLU;
14356	14062	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14357	14063	break;
14358	14064	}
14359		- case 18446744073709550973LLU: // 99999999z7'''''''''''''''
	14065	+ case 18446744073709550982LLU: // 999999990F'''''''''''''''
14360	14066	{
14361	14067
14362	14068	*LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0;

		@@ -14368,16 +14074,16 @@
14368	14074	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14369	14075	}
14370	14076	// ACCUMULATE ARGUMENTS - END
14371		- uint64_t return_to = 18446744073709550971LLU;
	14077	+ uint64_t return_to = 18446744073709550980LLU;
14372	14078	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14373	14079	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14374	14080	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
14375	14081	heap.data[0].elem1 = heap.data[0].elem0;
14376	14082	heap.data[0].elem0 = restore;
14377		- state.addr = 18446744073709551163LLU; // 9999999925'''''''''''''''
	14083	+ state.addr = 18446744073709551171LLU; // 999999993C'''''''''''''''
14378	14084	break;
14379	14085	}
14380		- case 18446744073709550971LLU: // 99999999z5'''''''''''''''
	14086	+ case 18446744073709550980LLU: // 999999990D'''''''''''''''
14381	14087	{
14382	14088	// ACCUMULATE ARGUMENTS - BEGIN
14383	14089	{

		@@ -14389,7 +14095,7 @@
14389	14095	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14390	14096	}
14391	14097	// ACCUMULATE ARGUMENTS - END
14392		- uint64_t return_to = 18446744073709550970LLU;
	14098	+ uint64_t return_to = 18446744073709550979LLU;
14393	14099	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14394	14100	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14395	14101	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14398,24 +14104,24 @@
14398	14104	state.addr = 58638376207779904LLU; // CPTypeDef_
14399	14105	break;
14400	14106	}
14401		- case 18446744073709550970LLU: // 99999999z4'''''''''''''''
	14107	+ case 18446744073709550979LLU: // 999999990C'''''''''''''''
14402	14108	{
14403		- state.addr = 18446744073709550972LLU; // 99999999z6'''''''''''''''
	14109	+ state.addr = 18446744073709550981LLU; // 999999990E'''''''''''''''
14404	14110	break;
14405	14111	}
14406		- case 18446744073709550972LLU: // 99999999z6'''''''''''''''
	14112	+ case 18446744073709550981LLU: // 999999990E'''''''''''''''
14407	14113	{
14408		- state.addr = 18446744073709550974LLU; // 99999999z8'''''''''''''''
	14114	+ state.addr = 18446744073709550983LLU; // 999999990G'''''''''''''''
14409	14115	break;
14410	14116	}
14411		- case 18446744073709550974LLU: // 99999999z8'''''''''''''''
	14117	+ case 18446744073709550983LLU: // 999999990G'''''''''''''''
14412	14118	{
14413	14119	// parameter-reference typedef___ elem______ goes out of scope
14414	14120	// parameter-reference list<typedef___> typedefs__ goes out of scope
14415		- state.addr = 18446744073709550977LLU; // 999999990A'''''''''''''''
	14121	+ state.addr = 18446744073709550986LLU; // 999999990J'''''''''''''''
14416	14122	break;
14417	14123	}
14418		- case 18446744073709550976LLU: // 999999990_'''''''''''''''
	14124	+ case 18446744073709550985LLU: // 999999990I'''''''''''''''
14419	14125	{
14420	14126	{
14421	14127	uint64_t arg = 0;

		@@ -14422,11 +14128,11 @@
14422	14128	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
14423	14129	}
14424	14130	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /notfound__/LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
14425		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550969LLU : 18446744073709550968LLU;
	14131	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550978LLU : 18446744073709550977LLU;
14426	14132	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14427	14133	break;
14428	14134	}
14429		- case 18446744073709550969LLU: // 99999999z3'''''''''''''''
	14135	+ case 18446744073709550978LLU: // 999999990B'''''''''''''''
14430	14136	{
14431	14137	// ACCUMULATE ARGUMENTS - BEGIN
14432	14138	{

		@@ -14438,7 +14144,7 @@
14438	14144	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14439	14145	}
14440	14146	// ACCUMULATE ARGUMENTS - END
14441		- uint64_t return_to = 18446744073709550967LLU;
	14147	+ uint64_t return_to = 18446744073709550976LLU;
14442	14148	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14443	14149	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14444	14150	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14447,7 +14153,7 @@
14447	14153	state.addr = 819847183518878446LLU; // reporttyps
14448	14154	break;
14449	14155	}
14450		- case 18446744073709550967LLU: // 99999999z1'''''''''''''''
	14156	+ case 18446744073709550976LLU: // 999999990_'''''''''''''''
14451	14157	{
14452	14158	// ACCUMULATE ARGUMENTS - BEGIN
14453	14159	{

		@@ -14455,7 +14161,7 @@
14455	14161	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14456	14162	}
14457	14163	// ACCUMULATE ARGUMENTS - END
14458		- uint64_t return_to = 18446744073709550966LLU;
	14164	+ uint64_t return_to = 18446744073709550975LLU;
14459	14165	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14460	14166	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14461	14167	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14464,7 +14170,7 @@
14464	14170	state.addr = 819847183515949359LLU; // reportinit
14465	14171	break;
14466	14172	}
14467		- case 18446744073709550966LLU: // 99999999z0'''''''''''''''
	14173	+ case 18446744073709550975LLU: // 99999999z9'''''''''''''''
14468	14174	{
14469	14175	fprintf(stderr, "%s", "no such type ");
14470	14176	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 3LLU)));

		@@ -14472,10 +14178,10 @@
14472	14178	fprintf(stderr, "%s\n", "");
14473	14179	exit(-1);
14474	14180	}
14475		- state.addr = 18446744073709550968LLU; // 99999999z2'''''''''''''''
	14181	+ state.addr = 18446744073709550977LLU; // 999999990A'''''''''''''''
14476	14182	break;
14477	14183	}
14478		- case 18446744073709550968LLU: // 99999999z2'''''''''''''''
	14184	+ case 18446744073709550977LLU: // 999999990A'''''''''''''''
14479	14185	{
14480	14186	// variable u64 notfound__ goes out of scope
14481	14187	// emitted destructur for type u64

		@@ -14516,7 +14222,7 @@
14516	14222	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14517	14223	}
14518	14224	// ACCUMULATE ARGUMENTS - END
14519		- uint64_t return_to = 18446744073709550965LLU;
	14225	+ uint64_t return_to = 18446744073709550974LLU;
14520	14226	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14521	14227	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14522	14228	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14525,7 +14231,7 @@
14525	14231	state.addr = 857578368147320832LLU; // tkstruct__
14526	14232	break;
14527	14233	}
14528		- case 18446744073709550965LLU: // 99999999zz'''''''''''''''
	14234	+ case 18446744073709550974LLU: // 99999999z8'''''''''''''''
14529	14235	{
14530	14236	// variable list<elemdef___> defpars___ goes out of scope
14531	14237	// (uninitialized -> no destructor-call)

		@@ -14543,10 +14249,10 @@
14543	14249	uint64_t arg = 0;
14544	14250	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14545	14251	}
14546		- state.addr = 18446744073709550964LLU; // 99999999zy'''''''''''''''
	14252	+ state.addr = 18446744073709550973LLU; // 99999999z7'''''''''''''''
14547	14253	break;
14548	14254	}
14549		- case 18446744073709550964LLU: // 99999999zy'''''''''''''''
	14255	+ case 18446744073709550973LLU: // 99999999z7'''''''''''''''
14550	14256	{
14551	14257	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
14552	14258	{

		@@ -14553,7 +14259,7 @@
14553	14259	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14554	14260	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14555	14261	{
14556		- state.addr = 18446744073709550963LLU; // 99999999zx'''''''''''''''
	14262	+ state.addr = 18446744073709550972LLU; // 99999999z6'''''''''''''''
14557	14263	break;
14558	14264	}
14559	14265	}

		@@ -14564,11 +14270,11 @@
14564	14270	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
14565	14271	}
14566	14272	LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /notfound__/LOCAL_ACCESS(heap.data, 9LLU, 5LLU);
14567		- state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550962LLU : 18446744073709550961LLU;
	14273	+ state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550971LLU : 18446744073709550970LLU;
14568	14274	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
14569	14275	break;
14570	14276	}
14571		- case 18446744073709550962LLU: // 99999999zw'''''''''''''''
	14277	+ case 18446744073709550971LLU: // 99999999z5'''''''''''''''
14572	14278	{
14573	14279	{
14574	14280	uint64_t arg = 0;

		@@ -14575,11 +14281,11 @@
14575	14281	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
14576	14282	}
14577	14283	LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 3LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU), 0LLU));
14578		- state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550960LLU : 18446744073709550959LLU;
	14284	+ state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550969LLU : 18446744073709550968LLU;
14579	14285	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
14580	14286	break;
14581	14287	}
14582		- case 18446744073709550960LLU: // 99999999zu'''''''''''''''
	14288	+ case 18446744073709550969LLU: // 99999999z3'''''''''''''''
14583	14289	{
14584	14290
14585	14291	*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) = 0;

		@@ -14591,16 +14297,16 @@
14591	14297	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14592	14298	}
14593	14299	// ACCUMULATE ARGUMENTS - END
14594		- uint64_t return_to = 18446744073709550958LLU;
	14300	+ uint64_t return_to = 18446744073709550967LLU;
14595	14301	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14596	14302	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14597	14303	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
14598	14304	heap.data[0].elem1 = heap.data[0].elem0;
14599	14305	heap.data[0].elem0 = restore;
14600		- state.addr = 18446744073709551203LLU; // 999999993h'''''''''''''''
	14306	+ state.addr = 18446744073709551211LLU; // 999999993p'''''''''''''''
14601	14307	break;
14602	14308	}
14603		- case 18446744073709550958LLU: // 99999999zs'''''''''''''''
	14309	+ case 18446744073709550967LLU: // 99999999z1'''''''''''''''
14604	14310	{
14605	14311	// ACCUMULATE ARGUMENTS - BEGIN
14606	14312	{

		@@ -14612,7 +14318,7 @@
14612	14318	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14613	14319	}
14614	14320	// ACCUMULATE ARGUMENTS - END
14615		- uint64_t return_to = 18446744073709550957LLU;
	14321	+ uint64_t return_to = 18446744073709550966LLU;
14616	14322	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14617	14323	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14618	14324	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14621,24 +14327,24 @@
14621	14327	state.addr = 66057855622447104LLU; // CopyTK____
14622	14328	break;
14623	14329	}
14624		- case 18446744073709550957LLU: // 99999999zr'''''''''''''''
	14330	+ case 18446744073709550966LLU: // 99999999z0'''''''''''''''
14625	14331	{
14626		- state.addr = 18446744073709550959LLU; // 99999999zt'''''''''''''''
	14332	+ state.addr = 18446744073709550968LLU; // 99999999z2'''''''''''''''
14627	14333	break;
14628	14334	}
14629		- case 18446744073709550959LLU: // 99999999zt'''''''''''''''
	14335	+ case 18446744073709550968LLU: // 99999999z2'''''''''''''''
14630	14336	{
14631		- state.addr = 18446744073709550961LLU; // 99999999zv'''''''''''''''
	14337	+ state.addr = 18446744073709550970LLU; // 99999999z4'''''''''''''''
14632	14338	break;
14633	14339	}
14634		- case 18446744073709550961LLU: // 99999999zv'''''''''''''''
	14340	+ case 18446744073709550970LLU: // 99999999z4'''''''''''''''
14635	14341	{
14636	14342	// parameter-reference typedef___ elem______ goes out of scope
14637	14343	// parameter-reference list<typedef___> typedefs__ goes out of scope
14638		- state.addr = 18446744073709550964LLU; // 99999999zy'''''''''''''''
	14344	+ state.addr = 18446744073709550973LLU; // 99999999z7'''''''''''''''
14639	14345	break;
14640	14346	}
14641		- case 18446744073709550963LLU: // 99999999zx'''''''''''''''
	14347	+ case 18446744073709550972LLU: // 99999999z6'''''''''''''''
14642	14348	{
14643	14349	{
14644	14350	uint64_t arg = 0;

		@@ -14645,11 +14351,11 @@
14645	14351	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
14646	14352	}
14647	14353	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /notfound__/LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
14648		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550956LLU : 18446744073709550955LLU;
	14354	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550965LLU : 18446744073709550964LLU;
14649	14355	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14650	14356	break;
14651	14357	}
14652		- case 18446744073709550956LLU: // 99999999zq'''''''''''''''
	14358	+ case 18446744073709550965LLU: // 99999999zz'''''''''''''''
14653	14359	{
14654	14360	// ACCUMULATE ARGUMENTS - BEGIN
14655	14361	{

		@@ -14661,7 +14367,7 @@
14661	14367	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14662	14368	}
14663	14369	// ACCUMULATE ARGUMENTS - END
14664		- uint64_t return_to = 18446744073709550954LLU;
	14370	+ uint64_t return_to = 18446744073709550963LLU;
14665	14371	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14666	14372	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14667	14373	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14670,7 +14376,7 @@
14670	14376	state.addr = 819847183518878446LLU; // reporttyps
14671	14377	break;
14672	14378	}
14673		- case 18446744073709550954LLU: // 99999999zo'''''''''''''''
	14379	+ case 18446744073709550963LLU: // 99999999zx'''''''''''''''
14674	14380	{
14675	14381	// ACCUMULATE ARGUMENTS - BEGIN
14676	14382	{

		@@ -14678,7 +14384,7 @@
14678	14384	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14679	14385	}
14680	14386	// ACCUMULATE ARGUMENTS - END
14681		- uint64_t return_to = 18446744073709550953LLU;
	14387	+ uint64_t return_to = 18446744073709550962LLU;
14682	14388	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14683	14389	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14684	14390	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14687,7 +14393,7 @@
14687	14393	state.addr = 819847183515949359LLU; // reportinit
14688	14394	break;
14689	14395	}
14690		- case 18446744073709550953LLU: // 99999999zn'''''''''''''''
	14396	+ case 18446744073709550962LLU: // 99999999zw'''''''''''''''
14691	14397	{
14692	14398	fprintf(stderr, "%s", "no such type ");
14693	14399	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)));

		@@ -14695,10 +14401,10 @@
14695	14401	fprintf(stderr, "%s\n", "");
14696	14402	exit(-1);
14697	14403	}
14698		- state.addr = 18446744073709550955LLU; // 99999999zp'''''''''''''''
	14404	+ state.addr = 18446744073709550964LLU; // 99999999zy'''''''''''''''
14699	14405	break;
14700	14406	}
14701		- case 18446744073709550955LLU: // 99999999zp'''''''''''''''
	14407	+ case 18446744073709550964LLU: // 99999999zy'''''''''''''''
14702	14408	{
14703	14409	swap(&LOCAL_ACCESS(heap.data, 6LLU, 4LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result
14704	14410	// variable u64 notfound__ goes out of scope

		@@ -14739,10 +14445,10 @@
14739	14445	uint64_t arg = 0;
14740	14446	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
14741	14447	}
14742		- state.addr = 18446744073709550952LLU; // 99999999zm'''''''''''''''
	14448	+ state.addr = 18446744073709550961LLU; // 99999999zv'''''''''''''''
14743	14449	break;
14744	14450	}
14745		- case 18446744073709550952LLU: // 99999999zm'''''''''''''''
	14451	+ case 18446744073709550961LLU: // 99999999zv'''''''''''''''
14746	14452	{
14747	14453	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
14748	14454	{

		@@ -14749,7 +14455,7 @@
14749	14455	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14750	14456	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14751	14457	{
14752		- state.addr = 18446744073709550951LLU; // 99999999zl'''''''''''''''
	14458	+ state.addr = 18446744073709550960LLU; // 99999999zu'''''''''''''''
14753	14459	break;
14754	14460	}
14755	14461	}

		@@ -14760,11 +14466,11 @@
14760	14466	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14761	14467	}
14762	14468	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /notfound__/LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
14763		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550950LLU : 18446744073709550949LLU;
	14469	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550959LLU : 18446744073709550958LLU;
14764	14470	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14765	14471	break;
14766	14472	}
14767		- case 18446744073709550950LLU: // 99999999zk'''''''''''''''
	14473	+ case 18446744073709550959LLU: // 99999999zt'''''''''''''''
14768	14474	{
14769	14475	{
14770	14476	uint64_t arg = 0;

		@@ -14771,32 +14477,32 @@
14771	14477	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14772	14478	}
14773	14479	LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU));
14774		- state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550948LLU : 18446744073709550947LLU;
	14480	+ state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550957LLU : 18446744073709550956LLU;
14775	14481	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14776	14482	break;
14777	14483	}
14778		- case 18446744073709550948LLU: // 99999999zi'''''''''''''''
	14484	+ case 18446744073709550957LLU: // 99999999zr'''''''''''''''
14779	14485	{
14780	14486
14781	14487	*LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0;
14782	14488
14783	14489	access_heap(heap.data, LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS(heap.data, 7LLU, 6LLU), 3LLU));
14784		- state.addr = 18446744073709550947LLU; // 99999999zh'''''''''''''''
	14490	+ state.addr = 18446744073709550956LLU; // 99999999zq'''''''''''''''
14785	14491	break;
14786	14492	}
14787		- case 18446744073709550947LLU: // 99999999zh'''''''''''''''
	14493	+ case 18446744073709550956LLU: // 99999999zq'''''''''''''''
14788	14494	{
14789		- state.addr = 18446744073709550949LLU; // 99999999zj'''''''''''''''
	14495	+ state.addr = 18446744073709550958LLU; // 99999999zs'''''''''''''''
14790	14496	break;
14791	14497	}
14792		- case 18446744073709550949LLU: // 99999999zj'''''''''''''''
	14498	+ case 18446744073709550958LLU: // 99999999zs'''''''''''''''
14793	14499	{
14794	14500	// parameter-reference typedef___ elem______ goes out of scope
14795	14501	// parameter-reference list<typedef___> typedefs__ goes out of scope
14796		- state.addr = 18446744073709550952LLU; // 99999999zm'''''''''''''''
	14502	+ state.addr = 18446744073709550961LLU; // 99999999zv'''''''''''''''
14797	14503	break;
14798	14504	}
14799		- case 18446744073709550951LLU: // 99999999zl'''''''''''''''
	14505	+ case 18446744073709550960LLU: // 99999999zu'''''''''''''''
14800	14506	{
14801	14507	{
14802	14508	uint64_t arg = 0;

		@@ -14803,11 +14509,11 @@
14803	14509	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
14804	14510	}
14805	14511	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /notfound__/LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
14806		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550946LLU : 18446744073709550945LLU;
	14512	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550955LLU : 18446744073709550954LLU;
14807	14513	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
14808	14514	break;
14809	14515	}
14810		- case 18446744073709550946LLU: // 99999999zg'''''''''''''''
	14516	+ case 18446744073709550955LLU: // 99999999zp'''''''''''''''
14811	14517	{
14812	14518	// ACCUMULATE ARGUMENTS - BEGIN
14813	14519	{

		@@ -14819,7 +14525,7 @@
14819	14525	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14820	14526	}
14821	14527	// ACCUMULATE ARGUMENTS - END
14822		- uint64_t return_to = 18446744073709550944LLU;
	14528	+ uint64_t return_to = 18446744073709550953LLU;
14823	14529	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14824	14530	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14825	14531	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14828,7 +14534,7 @@
14828	14534	state.addr = 819847183518878446LLU; // reporttyps
14829	14535	break;
14830	14536	}
14831		- case 18446744073709550944LLU: // 99999999ze'''''''''''''''
	14537	+ case 18446744073709550953LLU: // 99999999zn'''''''''''''''
14832	14538	{
14833	14539	// ACCUMULATE ARGUMENTS - BEGIN
14834	14540	{

		@@ -14836,7 +14542,7 @@
14836	14542	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14837	14543	}
14838	14544	// ACCUMULATE ARGUMENTS - END
14839		- uint64_t return_to = 18446744073709550943LLU;
	14545	+ uint64_t return_to = 18446744073709550952LLU;
14840	14546	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14841	14547	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14842	14548	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14845,7 +14551,7 @@
14845	14551	state.addr = 819847183515949359LLU; // reportinit
14846	14552	break;
14847	14553	}
14848		- case 18446744073709550943LLU: // 99999999zd'''''''''''''''
	14554	+ case 18446744073709550952LLU: // 99999999zm'''''''''''''''
14849	14555	{
14850	14556	fprintf(stderr, "%s", "no such type ");
14851	14557	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 3LLU)));

		@@ -14853,10 +14559,10 @@
14853	14559	fprintf(stderr, "%s\n", "");
14854	14560	exit(-1);
14855	14561	}
14856		- state.addr = 18446744073709550945LLU; // 99999999zf'''''''''''''''
	14562	+ state.addr = 18446744073709550954LLU; // 99999999zo'''''''''''''''
14857	14563	break;
14858	14564	}
14859		- case 18446744073709550945LLU: // 99999999zf'''''''''''''''
	14565	+ case 18446744073709550954LLU: // 99999999zo'''''''''''''''
14860	14566	{
14861	14567	// variable u64 notfound__ goes out of scope
14862	14568	// emitted destructur for type u64

		@@ -14897,10 +14603,10 @@
14897	14603	uint64_t arg = 0;
14898	14604	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
14899	14605	}
14900		- state.addr = 18446744073709550942LLU; // 99999999zc'''''''''''''''
	14606	+ state.addr = 18446744073709550951LLU; // 99999999zl'''''''''''''''
14901	14607	break;
14902	14608	}
14903		- case 18446744073709550942LLU: // 99999999zc'''''''''''''''
	14609	+ case 18446744073709550951LLU: // 99999999zl'''''''''''''''
14904	14610	{
14905	14611	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
14906	14612	{

		@@ -14907,7 +14613,7 @@
14907	14613	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
14908	14614	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14909	14615	{
14910		- state.addr = 18446744073709550941LLU; // 99999999zb'''''''''''''''
	14616	+ state.addr = 18446744073709550950LLU; // 99999999zk'''''''''''''''
14911	14617	break;
14912	14618	}
14913	14619	}

		@@ -14918,27 +14624,27 @@
14918	14624	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
14919	14625	}
14920	14626	LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 3LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU), 0LLU));
14921		- state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550940LLU : 18446744073709550939LLU;
	14627	+ state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550949LLU : 18446744073709550948LLU;
14922	14628	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 9
14923	14629	break;
14924	14630	}
14925		- case 18446744073709550940LLU: // 99999999za'''''''''''''''
	14631	+ case 18446744073709550949LLU: // 99999999zj'''''''''''''''
14926	14632	{
14927	14633
14928	14634	*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) = 0;
14929	14635
14930	14636	LOCAL_ACCESS(heap.data, 8LLU, 4LLU) = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 7LLU), 2LLU));
14931		- state.addr = 18446744073709550939LLU; // 99999999z$'''''''''''''''
	14637	+ state.addr = 18446744073709550948LLU; // 99999999zi'''''''''''''''
14932	14638	break;
14933	14639	}
14934		- case 18446744073709550939LLU: // 99999999z$'''''''''''''''
	14640	+ case 18446744073709550948LLU: // 99999999zi'''''''''''''''
14935	14641	{
14936	14642	// parameter-reference typedef___ elem______ goes out of scope
14937	14643	// parameter-reference list<typedef___> typedefs__ goes out of scope
14938		- state.addr = 18446744073709550942LLU; // 99999999zc'''''''''''''''
	14644	+ state.addr = 18446744073709550951LLU; // 99999999zl'''''''''''''''
14939	14645	break;
14940	14646	}
14941		- case 18446744073709550941LLU: // 99999999zb'''''''''''''''
	14647	+ case 18446744073709550950LLU: // 99999999zk'''''''''''''''
14942	14648	{
14943	14649	{
14944	14650	uint64_t arg = 0;

		@@ -14945,11 +14651,11 @@
14945	14651	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
14946	14652	}
14947	14653	LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /notfound__/LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
14948		- state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550938LLU : 18446744073709550937LLU;
	14654	+ state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550947LLU : 18446744073709550946LLU;
14949	14655	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
14950	14656	break;
14951	14657	}
14952		- case 18446744073709550938LLU: // 99999999zZ'''''''''''''''
	14658	+ case 18446744073709550947LLU: // 99999999zh'''''''''''''''
14953	14659	{
14954	14660	// ACCUMULATE ARGUMENTS - BEGIN
14955	14661	{

		@@ -14961,7 +14667,7 @@
14961	14667	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14962	14668	}
14963	14669	// ACCUMULATE ARGUMENTS - END
14964		- uint64_t return_to = 18446744073709550936LLU;
	14670	+ uint64_t return_to = 18446744073709550945LLU;
14965	14671	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
14966	14672	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14967	14673	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14970,7 +14676,7 @@
14970	14676	state.addr = 819847183518878446LLU; // reporttyps
14971	14677	break;
14972	14678	}
14973		- case 18446744073709550936LLU: // 99999999zX'''''''''''''''
	14679	+ case 18446744073709550945LLU: // 99999999zf'''''''''''''''
14974	14680	{
14975	14681	// ACCUMULATE ARGUMENTS - BEGIN
14976	14682	{

		@@ -14978,7 +14684,7 @@
14978	14684	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
14979	14685	}
14980	14686	// ACCUMULATE ARGUMENTS - END
14981		- uint64_t return_to = 18446744073709550935LLU;
	14687	+ uint64_t return_to = 18446744073709550944LLU;
14982	14688	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
14983	14689	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
14984	14690	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -14987,7 +14693,7 @@
14987	14693	state.addr = 819847183515949359LLU; // reportinit
14988	14694	break;
14989	14695	}
14990		- case 18446744073709550935LLU: // 99999999zW'''''''''''''''
	14696	+ case 18446744073709550944LLU: // 99999999ze'''''''''''''''
14991	14697	{
14992	14698	fprintf(stderr, "%s", "no such type ");
14993	14699	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)));

		@@ -14995,10 +14701,10 @@
14995	14701	fprintf(stderr, "%s\n", "");
14996	14702	exit(-1);
14997	14703	}
14998		- state.addr = 18446744073709550937LLU; // 99999999zY'''''''''''''''
	14704	+ state.addr = 18446744073709550946LLU; // 99999999zg'''''''''''''''
14999	14705	break;
15000	14706	}
15001		- case 18446744073709550937LLU: // 99999999zY'''''''''''''''
	14707	+ case 18446744073709550946LLU: // 99999999zg'''''''''''''''
15002	14708	{
15003	14709	access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = /sizeonheap/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
15004	14710	// variable u64 notfound__ goes out of scope

		@@ -15031,7 +14737,7 @@
15031	14737	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15032	14738	}
15033	14739	// ACCUMULATE ARGUMENTS - END
15034		- uint64_t return_to = 18446744073709550934LLU;
	14740	+ uint64_t return_to = 18446744073709550943LLU;
15035	14741	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15036	14742	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15037	14743	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15040,7 +14746,7 @@
15040	14746	state.addr = 787446708300855296LLU; // printtype_
15041	14747	break;
15042	14748	}
15043		- case 18446744073709550934LLU: // 99999999zV'''''''''''''''
	14749	+ case 18446744073709550943LLU: // 99999999zd'''''''''''''''
15044	14750	{
15045	14751	// parameter-reference elemdef___ elem______ goes out of scope
15046	14752	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference elem______ at 1

		@@ -15060,7 +14766,7 @@
15060	14766	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15061	14767	}
15062	14768	// ACCUMULATE ARGUMENTS - END
15063		- uint64_t return_to = 18446744073709550933LLU;
	14769	+ uint64_t return_to = 18446744073709550942LLU;
15064	14770	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15065	14771	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15066	14772	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15069,7 +14775,7 @@
15069	14775	state.addr = 787446708300855296LLU; // printtype_
15070	14776	break;
15071	14777	}
15072		- case 18446744073709550933LLU: // 99999999zU'''''''''''''''
	14778	+ case 18446744073709550942LLU: // 99999999zc'''''''''''''''
15073	14779	{
15074	14780	// parameter-reference pardef____ par_______ goes out of scope
15075	14781	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 1

		@@ -15135,7 +14841,7 @@
15135	14841	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15136	14842	}
15137	14843	// ACCUMULATE ARGUMENTS - END
15138		- uint64_t return_to = 18446744073709550932LLU;
	14844	+ uint64_t return_to = 18446744073709550941LLU;
15139	14845	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15140	14846	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15141	14847	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15144,7 +14850,7 @@
15144	14850	state.addr = 62098104378497011LLU; // CalcVarIdx
15145	14851	break;
15146	14852	}
15147		- case 18446744073709550932LLU: // 99999999zT'''''''''''''''
	14853	+ case 18446744073709550941LLU: // 99999999zb'''''''''''''''
15148	14854	{
15149	14855	// ACCUMULATE ARGUMENTS - BEGIN
15150	14856	{

		@@ -15152,7 +14858,7 @@
15152	14858	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15153	14859	}
15154	14860	// ACCUMULATE ARGUMENTS - END
15155		- uint64_t return_to = 18446744073709550931LLU;
	14861	+ uint64_t return_to = 18446744073709550940LLU;
15156	14862	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15157	14863	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15158	14864	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15161,7 +14867,7 @@
15161	14867	state.addr = 787446708198178816LLU; // printnr___
15162	14868	break;
15163	14869	}
15164		- case 18446744073709550931LLU: // 99999999zS'''''''''''''''
	14870	+ case 18446744073709550940LLU: // 99999999za'''''''''''''''
15165	14871	{
15166	14872	// variable u64 index_____ goes out of scope
15167	14873	// emitted destructur for type u64

		@@ -15204,7 +14910,7 @@
15204	14910	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15205	14911	}
15206	14912	// ACCUMULATE ARGUMENTS - END
15207		- uint64_t return_to = 18446744073709550930LLU;
	14913	+ uint64_t return_to = 18446744073709550939LLU;
15208	14914	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15209	14915	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15210	14916	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15213,7 +14919,7 @@
15213	14919	state.addr = 62098104378497011LLU; // CalcVarIdx
15214	14920	break;
15215	14921	}
15216		- case 18446744073709550930LLU: // 99999999zR'''''''''''''''
	14922	+ case 18446744073709550939LLU: // 99999999z$'''''''''''''''
15217	14923	{
15218	14924	fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, ");
15219	14925	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15222,7 +14928,7 @@
15222	14928	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15223	14929	}
15224	14930	// ACCUMULATE ARGUMENTS - END
15225		- uint64_t return_to = 18446744073709550929LLU;
	14931	+ uint64_t return_to = 18446744073709550938LLU;
15226	14932	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15227	14933	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15228	14934	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15231,7 +14937,7 @@
15231	14937	state.addr = 787446708198178816LLU; // printnr___
15232	14938	break;
15233	14939	}
15234		- case 18446744073709550929LLU: // 99999999zQ'''''''''''''''
	14940	+ case 18446744073709550938LLU: // 99999999zZ'''''''''''''''
15235	14941	{
15236	14942	fprintf(stdout, "%s", ", ");
15237	14943	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15240,7 +14946,7 @@
15240	14946	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15241	14947	}
15242	14948	// ACCUMULATE ARGUMENTS - END
15243		- uint64_t return_to = 18446744073709550928LLU;
	14949	+ uint64_t return_to = 18446744073709550937LLU;
15244	14950	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15245	14951	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15246	14952	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15249,7 +14955,7 @@
15249	14955	state.addr = 787446708198178816LLU; // printnr___
15250	14956	break;
15251	14957	}
15252		- case 18446744073709550928LLU: // 99999999zP'''''''''''''''
	14958	+ case 18446744073709550937LLU: // 99999999zY'''''''''''''''
15253	14959	{
15254	14960	fprintf(stdout, "%s", ")");
15255	14961	// variable u64 size______ goes out of scope

		@@ -15295,7 +15001,7 @@
15295	15001	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15296	15002	}
15297	15003	// ACCUMULATE ARGUMENTS - END
15298		- uint64_t return_to = 18446744073709550927LLU;
	15004	+ uint64_t return_to = 18446744073709550936LLU;
15299	15005	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15300	15006	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15301	15007	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15304,7 +15010,7 @@
15304	15010	state.addr = 62098104378497011LLU; // CalcVarIdx
15305	15011	break;
15306	15012	}
15307		- case 18446744073709550927LLU: // 99999999zO'''''''''''''''
	15013	+ case 18446744073709550936LLU: // 99999999zX'''''''''''''''
15308	15014	{
15309	15015	fprintf(stdout, "%s", "access_heap(heap.data, LOCAL_ACCESS(heap.data, ");
15310	15016	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15313,7 +15019,7 @@
15313	15019	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15314	15020	}
15315	15021	// ACCUMULATE ARGUMENTS - END
15316		- uint64_t return_to = 18446744073709550926LLU;
	15022	+ uint64_t return_to = 18446744073709550935LLU;
15317	15023	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15318	15024	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15319	15025	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15322,7 +15028,7 @@
15322	15028	state.addr = 787446708198178816LLU; // printnr___
15323	15029	break;
15324	15030	}
15325		- case 18446744073709550926LLU: // 99999999zN'''''''''''''''
	15031	+ case 18446744073709550935LLU: // 99999999zW'''''''''''''''
15326	15032	{
15327	15033	fprintf(stdout, "%s", ", ");
15328	15034	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15331,7 +15037,7 @@
15331	15037	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15332	15038	}
15333	15039	// ACCUMULATE ARGUMENTS - END
15334		- uint64_t return_to = 18446744073709550925LLU;
	15040	+ uint64_t return_to = 18446744073709550934LLU;
15335	15041	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15336	15042	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15337	15043	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15340,7 +15046,7 @@
15340	15046	state.addr = 787446708198178816LLU; // printnr___
15341	15047	break;
15342	15048	}
15343		- case 18446744073709550925LLU: // 99999999zM'''''''''''''''
	15049	+ case 18446744073709550934LLU: // 99999999zV'''''''''''''''
15344	15050	{
15345	15051	fprintf(stdout, "%s", "))");
15346	15052	// variable u64 size______ goes out of scope

		@@ -15386,7 +15092,7 @@
15386	15092	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15387	15093	}
15388	15094	// ACCUMULATE ARGUMENTS - END
15389		- uint64_t return_to = 18446744073709550924LLU;
	15095	+ uint64_t return_to = 18446744073709550933LLU;
15390	15096	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15391	15097	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15392	15098	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15395,7 +15101,7 @@
15395	15101	state.addr = 62098104378497011LLU; // CalcVarIdx
15396	15102	break;
15397	15103	}
15398		- case 18446744073709550924LLU: // 99999999zL'''''''''''''''
	15104	+ case 18446744073709550933LLU: // 99999999zU'''''''''''''''
15399	15105	{
15400	15106	fprintf(stdout, "%s", "LOCAL_ACCESS_ADDR(heap.data, ");
15401	15107	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15404,7 +15110,7 @@
15404	15110	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15405	15111	}
15406	15112	// ACCUMULATE ARGUMENTS - END
15407		- uint64_t return_to = 18446744073709550923LLU;
	15113	+ uint64_t return_to = 18446744073709550932LLU;
15408	15114	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15409	15115	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15410	15116	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15413,7 +15119,7 @@
15413	15119	state.addr = 787446708198178816LLU; // printnr___
15414	15120	break;
15415	15121	}
15416		- case 18446744073709550923LLU: // 99999999zK'''''''''''''''
	15122	+ case 18446744073709550932LLU: // 99999999zT'''''''''''''''
15417	15123	{
15418	15124	fprintf(stdout, "%s", ", ");
15419	15125	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15422,7 +15128,7 @@
15422	15128	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15423	15129	}
15424	15130	// ACCUMULATE ARGUMENTS - END
15425		- uint64_t return_to = 18446744073709550922LLU;
	15131	+ uint64_t return_to = 18446744073709550931LLU;
15426	15132	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15427	15133	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15428	15134	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15431,7 +15137,7 @@
15431	15137	state.addr = 787446708198178816LLU; // printnr___
15432	15138	break;
15433	15139	}
15434		- case 18446744073709550922LLU: // 99999999zJ'''''''''''''''
	15140	+ case 18446744073709550931LLU: // 99999999zS'''''''''''''''
15435	15141	{
15436	15142	fprintf(stdout, "%s", ")");
15437	15143	// variable u64 size______ goes out of scope

		@@ -15477,7 +15183,7 @@
15477	15183	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15478	15184	}
15479	15185	// ACCUMULATE ARGUMENTS - END
15480		- uint64_t return_to = 18446744073709550921LLU;
	15186	+ uint64_t return_to = 18446744073709550930LLU;
15481	15187	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15482	15188	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15483	15189	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15486,7 +15192,7 @@
15486	15192	state.addr = 62098104378497011LLU; // CalcVarIdx
15487	15193	break;
15488	15194	}
15489		- case 18446744073709550921LLU: // 99999999zI'''''''''''''''
	15195	+ case 18446744073709550930LLU: // 99999999zR'''''''''''''''
15490	15196	{
15491	15197	fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, ");
15492	15198	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15495,7 +15201,7 @@
15495	15201	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15496	15202	}
15497	15203	// ACCUMULATE ARGUMENTS - END
15498		- uint64_t return_to = 18446744073709550920LLU;
	15204	+ uint64_t return_to = 18446744073709550929LLU;
15499	15205	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15500	15206	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15501	15207	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15504,7 +15210,7 @@
15504	15210	state.addr = 787446708198178816LLU; // printnr___
15505	15211	break;
15506	15212	}
15507		- case 18446744073709550920LLU: // 99999999zH'''''''''''''''
	15213	+ case 18446744073709550929LLU: // 99999999zQ'''''''''''''''
15508	15214	{
15509	15215	fprintf(stdout, "%s", ", ");
15510	15216	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -15513,7 +15219,7 @@
15513	15219	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15514	15220	}
15515	15221	// ACCUMULATE ARGUMENTS - END
15516		- uint64_t return_to = 18446744073709550919LLU;
	15222	+ uint64_t return_to = 18446744073709550928LLU;
15517	15223	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
15518	15224	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15519	15225	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15522,7 +15228,7 @@
15522	15228	state.addr = 787446708198178816LLU; // printnr___
15523	15229	break;
15524	15230	}
15525		- case 18446744073709550919LLU: // 99999999zG'''''''''''''''
	15231	+ case 18446744073709550928LLU: // 99999999zP'''''''''''''''
15526	15232	{
15527	15233	fprintf(stdout, "%s", ")");
15528	15234	// variable u64 size______ goes out of scope

		@@ -15551,11 +15257,11 @@
15551	15257	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
15552	15258	}
15553	15259	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /INDIRECT__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
15554		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550918LLU : 18446744073709550917LLU;
	15260	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550927LLU : 18446744073709550926LLU;
15555	15261	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
15556	15262	break;
15557	15263	}
15558		- case 18446744073709550918LLU: // 99999999zF'''''''''''''''
	15264	+ case 18446744073709550927LLU: // 99999999zO'''''''''''''''
15559	15265	{
15560	15266	// ACCUMULATE ARGUMENTS - BEGIN
15561	15267	{

		@@ -15575,7 +15281,7 @@
15575	15281	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15576	15282	}
15577	15283	// ACCUMULATE ARGUMENTS - END
15578		- uint64_t return_to = 18446744073709550915LLU;
	15284	+ uint64_t return_to = 18446744073709550924LLU;
15579	15285	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15580	15286	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15581	15287	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15584,12 +15290,12 @@
15584	15290	state.addr = 587881359725709919LLU; // emitrefind
15585	15291	break;
15586	15292	}
15587		- case 18446744073709550915LLU: // 99999999zC'''''''''''''''
	15293	+ case 18446744073709550924LLU: // 99999999zL'''''''''''''''
15588	15294	{
15589		- state.addr = 18446744073709550916LLU; // 99999999zD'''''''''''''''
	15295	+ state.addr = 18446744073709550925LLU; // 99999999zM'''''''''''''''
15590	15296	break;
15591	15297	}
15592		- case 18446744073709550917LLU: // 99999999zE'''''''''''''''
	15298	+ case 18446744073709550926LLU: // 99999999zN'''''''''''''''
15593	15299	{
15594	15300	// ACCUMULATE ARGUMENTS - BEGIN
15595	15301	{

		@@ -15609,7 +15315,7 @@
15609	15315	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15610	15316	}
15611	15317	// ACCUMULATE ARGUMENTS - END
15612		- uint64_t return_to = 18446744073709550914LLU;
	15318	+ uint64_t return_to = 18446744073709550923LLU;
15613	15319	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15614	15320	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15615	15321	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15618,12 +15324,12 @@
15618	15324	state.addr = 587881363956714079LLU; // emitvarind
15619	15325	break;
15620	15326	}
15621		- case 18446744073709550914LLU: // 99999999zB'''''''''''''''
	15327	+ case 18446744073709550923LLU: // 99999999zK'''''''''''''''
15622	15328	{
15623		- state.addr = 18446744073709550916LLU; // 99999999zD'''''''''''''''
	15329	+ state.addr = 18446744073709550925LLU; // 99999999zM'''''''''''''''
15624	15330	break;
15625	15331	}
15626		- case 18446744073709550916LLU: // 99999999zD'''''''''''''''
	15332	+ case 18446744073709550925LLU: // 99999999zM'''''''''''''''
15627	15333	{
15628	15334	// parameter-reference u64 INDIRECT__ goes out of scope
15629	15335	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 5

		@@ -15650,11 +15356,11 @@
15650	15356	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
15651	15357	}
15652	15358	LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /INDIRECT__/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
15653		- state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550913LLU : 18446744073709550912LLU;
	15359	+ state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550922LLU : 18446744073709550921LLU;
15654	15360	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
15655	15361	break;
15656	15362	}
15657		- case 18446744073709550913LLU: // 99999999zA'''''''''''''''
	15363	+ case 18446744073709550922LLU: // 99999999zJ'''''''''''''''
15658	15364	{
15659	15365	// ACCUMULATE ARGUMENTS - BEGIN
15660	15366	{

		@@ -15674,7 +15380,7 @@
15674	15380	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15675	15381	}
15676	15382	// ACCUMULATE ARGUMENTS - END
15677		- uint64_t return_to = 18446744073709550910LLU;
	15383	+ uint64_t return_to = 18446744073709550919LLU;
15678	15384	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15679	15385	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15680	15386	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15683,12 +15389,12 @@
15683	15389	state.addr = 587881359725559808LLU; // emitref___
15684	15390	break;
15685	15391	}
15686		- case 18446744073709550910LLU: // 99999999y8'''''''''''''''
	15392	+ case 18446744073709550919LLU: // 99999999zG'''''''''''''''
15687	15393	{
15688		- state.addr = 18446744073709550911LLU; // 99999999y9'''''''''''''''
	15394	+ state.addr = 18446744073709550920LLU; // 99999999zH'''''''''''''''
15689	15395	break;
15690	15396	}
15691		- case 18446744073709550912LLU: // 99999999z_'''''''''''''''
	15397	+ case 18446744073709550921LLU: // 99999999zI'''''''''''''''
15692	15398	{
15693	15399	// ACCUMULATE ARGUMENTS - BEGIN
15694	15400	{

		@@ -15708,7 +15414,7 @@
15708	15414	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
15709	15415	}
15710	15416	// ACCUMULATE ARGUMENTS - END
15711		- uint64_t return_to = 18446744073709550909LLU;
	15417	+ uint64_t return_to = 18446744073709550918LLU;
15712	15418	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
15713	15419	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
15714	15420	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -15717,12 +15423,12 @@
15717	15423	state.addr = 587881363956563968LLU; // emitvar___
15718	15424	break;
15719	15425	}
15720		- case 18446744073709550909LLU: // 99999999y7'''''''''''''''
	15426	+ case 18446744073709550918LLU: // 99999999zF'''''''''''''''
15721	15427	{
15722		- state.addr = 18446744073709550911LLU; // 99999999y9'''''''''''''''
	15428	+ state.addr = 18446744073709550920LLU; // 99999999zH'''''''''''''''
15723	15429	break;
15724	15430	}
15725		- case 18446744073709550911LLU: // 99999999y9'''''''''''''''
	15431	+ case 18446744073709550920LLU: // 99999999zH'''''''''''''''
15726	15432	{
15727	15433	// parameter-reference u64 INDIRECT__ goes out of scope
15728	15434	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 5

		@@ -15750,22 +15456,22 @@
15750	15456	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);

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

Show on old repository browser