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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisão	946 (tree)
Hora	2020-03-26 04:48:02
Autor	jakobthomsen

Mensagem de Log

implement tuple-assignment from value/variable

Mudança Sumário

Diff

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

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

		@@ -59266,36 +59266,277 @@
59266	59266	uint64_t arg = 0LLU;
59267	59267	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
59268	59268	}
	59269	+ {
	59270	+ uint64_t arg = 0;
	59271	+ LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
	59272	+ }
59269	59273	// ACCUMULATE ARGUMENTS - BEGIN
59270	59274	{
59271		- uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 20LLU, 11LLU);
	59275	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU);
59272	59276	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59273	59277	}
	59278	+ {
	59279	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU);
	59280	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59281	+ }
59274	59282	// ACCUMULATE ARGUMENTS - END
59275		- uint64_t return_to = 18446744073709548120LLU;
	59283	+ uint64_t return_to = 18446744073709548118LLU;
	59284	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	59285	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59286	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59287	+ heap.data[0].elem1 = heap.data[0].elem0;
	59288	+ heap.data[0].elem0 = restore;
	59289	+ state.addr = 661605045736570880LLU; // isdigit___
	59290	+ break;
	59291	+ }
	59292	+ case 18446744073709548118LLU: // 99999999IV'''''''''''''''
	59293	+ {
	59294	+ state.addr = 18446744073709548119LLU; // 99999999IW'''''''''''''''
	59295	+ break;
	59296	+ }
	59297	+ case 18446744073709548119LLU: // 99999999IW'''''''''''''''
	59298	+ {
	59299	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548121LLU : 18446744073709548120LLU;
	59300	+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
	59301	+ break;
	59302	+ }
	59303	+ case 18446744073709548121LLU: // 99999999IY'''''''''''''''
	59304	+ {
	59305	+ {
	59306	+ uint64_t arg = 0LLU;
	59307	+ LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
	59308	+ }
	59309	+ /nr________/LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)));
	59310	+ state.addr = /newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548117LLU : 18446744073709548116LLU;
	59311	+ break;
	59312	+ }
	59313	+ case 18446744073709548117LLU: // 99999999IU'''''''''''''''
	59314	+ {
	59315	+ {
	59316	+ uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 16LLU))/list/, 8);
	59317	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	59318	+ }
	59319	+ state.addr = /newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 16LLU)) ? 18446744073709548115LLU : 18446744073709548114LLU;
	59320	+ break;
	59321	+ }
	59322	+ case 18446744073709548115LLU: // 99999999IS'''''''''''''''
	59323	+ {
	59324	+ {
	59325	+ uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 16LLU))/list/, 8);
	59326	+ LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
	59327	+ }
	59328	+ // ACCUMULATE ARGUMENTS - BEGIN
	59329	+ {
	59330	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 23LLU, 0LLU);
	59331	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59332	+ }
	59333	+ // ACCUMULATE ARGUMENTS - END
	59334	+ uint64_t return_to = 18446744073709548112LLU;
59276	59335	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
59277	59336	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59278	59337	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
59279	59338	heap.data[0].elem1 = heap.data[0].elem0;
59280	59339	heap.data[0].elem0 = restore;
59281		- state.addr = 839519719621918720LLU; // skipws____
	59340	+ state.addr = 819847183515949359LLU; // reportinit
59282	59341	break;
59283	59342	}
59284		- case 18446744073709548120LLU: // 99999999IX'''''''''''''''
	59343	+ case 18446744073709548112LLU: // 99999999IP'''''''''''''''
59285	59344	{
59286		- state.addr = 18446744073709548121LLU; // 99999999IY'''''''''''''''
	59345	+ state.addr = 18446744073709548113LLU; // 99999999IQ'''''''''''''''
59287	59346	break;
59288	59347	}
59289		- case 18446744073709548121LLU: // 99999999IY'''''''''''''''
	59348	+ case 18446744073709548113LLU: // 99999999IQ'''''''''''''''
59290	59349	{
	59350	+ fprintf(stderr, "%s", "superfluous result in assignment from ");
	59351	+ fprintf(stderr, "%llu", (unsigned long long)/nr________/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU));
	59352	+ {
	59353	+ fprintf(stderr, "%s\n", "");
	59354	+ exit(-1);
	59355	+ }
	59356	+ // variable resdest___ result____ goes out of scope
	59357	+ // emitted destructur for type resdest___
	59358	+ // ACCUMULATE ARGUMENTS - BEGIN
	59359	+ {
	59360	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU);
	59361	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59362	+ }
	59363	+ // ACCUMULATE ARGUMENTS - END
	59364	+ uint64_t return_to = 18446744073709548111LLU;
	59365	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59366	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59367	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59368	+ heap.data[0].elem1 = heap.data[0].elem0;
	59369	+ heap.data[0].elem0 = restore;
	59370	+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
	59371	+ break;
	59372	+ }
	59373	+ case 18446744073709548111LLU: // 99999999IO'''''''''''''''
	59374	+ {
	59375	+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 23
	59376	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59377	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59378	+ state.addr = 18446744073709548110LLU; // 99999999IN'''''''''''''''
	59379	+ break;
	59380	+ }
	59381	+ case 18446744073709548114LLU: // 99999999IR'''''''''''''''
	59382	+ {
	59383	+ // ACCUMULATE ARGUMENTS - BEGIN
	59384	+ {
	59385	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 22LLU, 0LLU);
	59386	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59387	+ }
	59388	+ {
	59389	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU), 0LLU);
	59390	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59391	+ }
	59392	+ // ACCUMULATE ARGUMENTS - END
	59393	+ uint64_t return_to = 18446744073709548108LLU;
	59394	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	59395	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59396	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59397	+ heap.data[0].elem1 = heap.data[0].elem0;
	59398	+ heap.data[0].elem0 = restore;
	59399	+ state.addr = 517555565476695680LLU; // assertu64_
	59400	+ break;
	59401	+ }
	59402	+ case 18446744073709548108LLU: // 99999999IL'''''''''''''''
	59403	+ {
	59404	+ state.addr = 18446744073709548109LLU; // 99999999IM'''''''''''''''
	59405	+ break;
	59406	+ }
	59407	+ case 18446744073709548109LLU: // 99999999IM'''''''''''''''
	59408	+ {
	59409	+ fprintf(stdout, "%s", "\n ");
	59410	+ // ACCUMULATE ARGUMENTS - BEGIN
	59411	+ {
	59412	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU);
	59413	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59414	+ }
	59415	+ {
	59416	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU);
	59417	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59418	+ }
	59419	+ {
	59420	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU);
	59421	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59422	+ }
	59423	+ {
	59424	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU), 1LLU);
	59425	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59426	+ }
	59427	+ {
	59428	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU), 2LLU);
	59429	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59430	+ }
	59431	+ // ACCUMULATE ARGUMENTS - END
	59432	+ uint64_t return_to = 18446744073709548106LLU;
	59433	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
	59434	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59435	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59436	+ heap.data[0].elem1 = heap.data[0].elem0;
	59437	+ heap.data[0].elem0 = restore;
	59438	+ state.addr = 587881357514113024LLU; // emitpar___
	59439	+ break;
	59440	+ }
	59441	+ case 18446744073709548106LLU: // 99999999IJ'''''''''''''''
	59442	+ {
	59443	+ state.addr = 18446744073709548107LLU; // 99999999IK'''''''''''''''
	59444	+ break;
	59445	+ }
	59446	+ case 18446744073709548107LLU: // 99999999IK'''''''''''''''
	59447	+ {
	59448	+ fprintf(stdout, "%s", " = ");
	59449	+ fprintf(stdout, "%llu", (unsigned long long)/nr________/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU));
	59450	+ fprintf(stdout, "%s", ";");
	59451	+ ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stdin);
	59452	+ if(';' != (char)getchar())
	59453	+ {
	59454	+ fprintf(stderr, "match failed at char %c\n", (char)59LLU);
	59455	+ exit(-1);
	59456	+ }
	59457	+ state.addr = 18446744073709548110LLU; // 99999999IN'''''''''''''''
	59458	+ break;
	59459	+ }
	59460	+ case 18446744073709548110LLU: // 99999999IN'''''''''''''''
	59461	+ {
	59462	+ // variable resdest___ result____ goes out of scope
	59463	+ // emitted destructur for type resdest___
	59464	+ // ACCUMULATE ARGUMENTS - BEGIN
	59465	+ {
	59466	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	59467	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59468	+ }
	59469	+ // ACCUMULATE ARGUMENTS - END
	59470	+ uint64_t return_to = 18446744073709548105LLU;
	59471	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59472	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59473	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59474	+ heap.data[0].elem1 = heap.data[0].elem0;
	59475	+ heap.data[0].elem0 = restore;
	59476	+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
	59477	+ break;
	59478	+ }
	59479	+ case 18446744073709548105LLU: // 99999999II'''''''''''''''
	59480	+ {
	59481	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 22
	59482	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59483	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59484	+ state.addr = 18446744073709548104LLU; // 99999999IH'''''''''''''''
	59485	+ break;
	59486	+ }
	59487	+ case 18446744073709548116LLU: // 99999999IT'''''''''''''''
	59488	+ {
	59489	+ // ACCUMULATE ARGUMENTS - BEGIN
	59490	+ {
	59491	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 21LLU, 0LLU);
	59492	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59493	+ }
	59494	+ // ACCUMULATE ARGUMENTS - END
	59495	+ uint64_t return_to = 18446744073709548102LLU;
	59496	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59497	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59498	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59499	+ heap.data[0].elem1 = heap.data[0].elem0;
	59500	+ heap.data[0].elem0 = restore;
	59501	+ state.addr = 819847183515949359LLU; // reportinit
	59502	+ break;
	59503	+ }
	59504	+ case 18446744073709548102LLU: // 99999999IF'''''''''''''''
	59505	+ {
	59506	+ state.addr = 18446744073709548103LLU; // 99999999IG'''''''''''''''
	59507	+ break;
	59508	+ }
	59509	+ case 18446744073709548103LLU: // 99999999IG'''''''''''''''
	59510	+ {
	59511	+ fprintf(stderr, "%s", "missing result in assignment from ");
	59512	+ printid(stderr, /nr________/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU));
	59513	+ {
	59514	+ fprintf(stderr, "%s\n", "");
	59515	+ exit(-1);
	59516	+ }
	59517	+ state.addr = 18446744073709548104LLU; // 99999999IH'''''''''''''''
	59518	+ break;
	59519	+ }
	59520	+ case 18446744073709548104LLU: // 99999999IH'''''''''''''''
	59521	+ {
	59522	+ // variable u64 nr________ goes out of scope
	59523	+ // emitted destructur for type u64
	59524	+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 21
	59525	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59526	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59527	+ state.addr = 18446744073709548101LLU; // 99999999IE'''''''''''''''
	59528	+ break;
	59529	+ }
	59530	+ case 18446744073709548120LLU: // 99999999IX'''''''''''''''
	59531	+ {
59291	59532	/callee_id_/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)));
59292	59533	*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 657807020572803072LLU;
59293	59534
59294	59535	/matchsym__/LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /callee_id_/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
59295		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548119LLU : 18446744073709548118LLU;
	59536	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548100LLU : 18446744073709548099LLU;
59296	59537	break;
59297	59538	}
59298		- case 18446744073709548119LLU: // 99999999IW'''''''''''''''
	59539	+ case 18446744073709548100LLU: // 99999999ID'''''''''''''''
59299	59540	{
59300	59541	// ACCUMULATE ARGUMENTS - BEGIN
59301	59542	{

		@@ -59363,7 +59604,7 @@
59363	59604	LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59364	59605	}
59365	59606	// ACCUMULATE ARGUMENTS - END
59366		- uint64_t return_to = 18446744073709548116LLU;
	59607	+ uint64_t return_to = 18446744073709548097LLU;
59367	59608	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0));
59368	59609	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59369	59610	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59372,28 +59613,28 @@
59372	59613	state.addr = 787472328605827072LLU; // procif____
59373	59614	break;
59374	59615	}
59375		- case 18446744073709548116LLU: // 99999999IT'''''''''''''''
	59616	+ case 18446744073709548097LLU: // 99999999IA'''''''''''''''
59376	59617	{
59377		- state.addr = 18446744073709548117LLU; // 99999999IU'''''''''''''''
	59618	+ state.addr = 18446744073709548098LLU; // 99999999IB'''''''''''''''
59378	59619	break;
59379	59620	}
59380		- case 18446744073709548117LLU: // 99999999IU'''''''''''''''
	59621	+ case 18446744073709548098LLU: // 99999999IB'''''''''''''''
59381	59622	{
59382	59623	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
59383	59624	heap.availilable_size_for_dynamic_objects += 0LLU;
59384	59625	heap.availilable_size_for_dynamic_objects += 0LLU;
59385		- state.addr = 18446744073709548115LLU; // 99999999IS'''''''''''''''
	59626	+ state.addr = 18446744073709548096LLU; // 99999999I_'''''''''''''''
59386	59627	break;
59387	59628	}
59388		- case 18446744073709548118LLU: // 99999999IV'''''''''''''''
	59629	+ case 18446744073709548099LLU: // 99999999IC'''''''''''''''
59389	59630	{
59390	59631	*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) = 512981598149279744LLU;
59391	59632
59392	59633	/matchsym__/LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /callee_id_/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
59393		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548114LLU : 18446744073709548113LLU;
	59634	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548095LLU : 18446744073709548094LLU;
59394	59635	break;
59395	59636	}
59396		- case 18446744073709548114LLU: // 99999999IR'''''''''''''''
	59637	+ case 18446744073709548095LLU: // 99999999H9'''''''''''''''
59397	59638	{
59398	59639	// ACCUMULATE ARGUMENTS - BEGIN
59399	59640	{

		@@ -59441,7 +59682,7 @@
59441	59682	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59442	59683	}
59443	59684	// ACCUMULATE ARGUMENTS - END
59444		- uint64_t return_to = 18446744073709548111LLU;
	59685	+ uint64_t return_to = 18446744073709548092LLU;
59445	59686	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
59446	59687	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59447	59688	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59450,20 +59691,20 @@
59450	59691	state.addr = 787472319973559214LLU; // procaccess
59451	59692	break;
59452	59693	}
59453		- case 18446744073709548111LLU: // 99999999IO'''''''''''''''
	59694	+ case 18446744073709548092LLU: // 99999999H6'''''''''''''''
59454	59695	{
59455		- state.addr = 18446744073709548112LLU; // 99999999IP'''''''''''''''
	59696	+ state.addr = 18446744073709548093LLU; // 99999999H7'''''''''''''''
59456	59697	break;
59457	59698	}
59458		- case 18446744073709548112LLU: // 99999999IP'''''''''''''''
	59699	+ case 18446744073709548093LLU: // 99999999H7'''''''''''''''
59459	59700	{
59460	59701	swap(&/results___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 16LLU)));
59461	59702	heap.availilable_size_for_dynamic_objects += 0LLU;
59462	59703	heap.availilable_size_for_dynamic_objects += 0LLU;
59463		- state.addr = 18446744073709548110LLU; // 99999999IN'''''''''''''''
	59704	+ state.addr = 18446744073709548091LLU; // 99999999H5'''''''''''''''
59464	59705	break;
59465	59706	}
59466		- case 18446744073709548113LLU: // 99999999IQ'''''''''''''''
	59707	+ case 18446744073709548094LLU: // 99999999H8'''''''''''''''
59467	59708	{
59468	59709	*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = 0LLU;
59469	59710

		@@ -59475,7 +59716,7 @@
59475	59716	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59476	59717	}
59477	59718	// ACCUMULATE ARGUMENTS - END
59478		- uint64_t return_to = 18446744073709548108LLU;
	59719	+ uint64_t return_to = 18446744073709548089LLU;
59479	59720	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
59480	59721	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59481	59722	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59484,18 +59725,18 @@
59484	59725	state.addr = 839519719621918720LLU; // skipws____
59485	59726	break;
59486	59727	}
59487		- case 18446744073709548108LLU: // 99999999IL'''''''''''''''
	59728	+ case 18446744073709548089LLU: // 99999999H3'''''''''''''''
59488	59729	{
59489		- state.addr = 18446744073709548109LLU; // 99999999IM'''''''''''''''
	59730	+ state.addr = 18446744073709548090LLU; // 99999999H4'''''''''''''''
59490	59731	break;
59491	59732	}
59492		- case 18446744073709548109LLU: // 99999999IM'''''''''''''''
	59733	+ case 18446744073709548090LLU: // 99999999H4'''''''''''''''
59493	59734	{
59494	59735	/matchsym__/LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = /sym_______/LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 11LLU));
59495		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548107LLU : 18446744073709548106LLU;
	59736	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709548088LLU : 18446744073709548087LLU;
59496	59737	break;
59497	59738	}
59498		- case 18446744073709548107LLU: // 99999999IK'''''''''''''''
	59739	+ case 18446744073709548088LLU: // 99999999H2'''''''''''''''
59499	59740	{
59500	59741	// ACCUMULATE ARGUMENTS - BEGIN
59501	59742	{

		@@ -59567,7 +59808,7 @@
59567	59808	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59568	59809	}
59569	59810	// ACCUMULATE ARGUMENTS - END
59570		- uint64_t return_to = 18446744073709548104LLU;
	59811	+ uint64_t return_to = 18446744073709548085LLU;
59571	59812	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
59572	59813	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59573	59814	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59576,39 +59817,410 @@
59576	59817	state.addr = 782701543315110336LLU; // parsecall_
59577	59818	break;
59578	59819	}
59579		- case 18446744073709548104LLU: // 99999999IH'''''''''''''''
	59820	+ case 18446744073709548085LLU: // 99999999Hz'''''''''''''''
59580	59821	{
59581		- state.addr = 18446744073709548105LLU; // 99999999II'''''''''''''''
	59822	+ state.addr = 18446744073709548086LLU; // 99999999H0'''''''''''''''
59582	59823	break;
59583	59824	}
59584		- case 18446744073709548105LLU: // 99999999II'''''''''''''''
	59825	+ case 18446744073709548086LLU: // 99999999H0'''''''''''''''
59585	59826	{
59586	59827	heap.availilable_size_for_dynamic_objects += 0LLU;
59587	59828	heap.availilable_size_for_dynamic_objects += 0LLU;
59588		- state.addr = 18446744073709548103LLU; // 99999999IG'''''''''''''''
	59829	+ state.addr = 18446744073709548084LLU; // 99999999Hy'''''''''''''''
59589	59830	break;
59590	59831	}
59591		- case 18446744073709548106LLU: // 99999999IJ'''''''''''''''
	59832	+ case 18446744073709548087LLU: // 99999999H1'''''''''''''''
59592	59833	{
	59834	+ state.addr = /newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 16LLU)) ? 18446744073709548083LLU : 18446744073709548082LLU;
	59835	+ break;
	59836	+ }
	59837	+ case 18446744073709548083LLU: // 99999999Hx'''''''''''''''
	59838	+ {
59593	59839	{
59594		- fprintf(stderr, "%s\n", "returning id not implemented");
	59840	+ uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 16LLU))/list/, 8);
	59841	+ LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
	59842	+ }
	59843	+ state.addr = /newresults/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 16LLU)) ? 18446744073709548081LLU : 18446744073709548080LLU;
	59844	+ break;
	59845	+ }
	59846	+ case 18446744073709548081LLU: // 99999999Hv'''''''''''''''
	59847	+ {
	59848	+ {
	59849	+ uint64_t arg = list_pop_move(&heap, &access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 16LLU))/list/, 8);
	59850	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	59851	+ }
	59852	+ // ACCUMULATE ARGUMENTS - BEGIN
	59853	+ {
	59854	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 22LLU, 0LLU);
	59855	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59856	+ }
	59857	+ // ACCUMULATE ARGUMENTS - END
	59858	+ uint64_t return_to = 18446744073709548078LLU;
	59859	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59860	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59861	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59862	+ heap.data[0].elem1 = heap.data[0].elem0;
	59863	+ heap.data[0].elem0 = restore;
	59864	+ state.addr = 819847183515949359LLU; // reportinit
	59865	+ break;
	59866	+ }
	59867	+ case 18446744073709548078LLU: // 99999999Hs'''''''''''''''
	59868	+ {
	59869	+ state.addr = 18446744073709548079LLU; // 99999999Ht'''''''''''''''
	59870	+ break;
	59871	+ }
	59872	+ case 18446744073709548079LLU: // 99999999Ht'''''''''''''''
	59873	+ {
	59874	+ fprintf(stderr, "%s", "superfluous result in assignment from ");
	59875	+ printid(stderr, /callee_id_/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU));
	59876	+ {
	59877	+ fprintf(stderr, "%s\n", "");
59595	59878	exit(-1);
59596	59879	}
59597		- state.addr = 18446744073709548103LLU; // 99999999IG'''''''''''''''
	59880	+ // variable resdest___ result____ goes out of scope
	59881	+ // emitted destructur for type resdest___
	59882	+ // ACCUMULATE ARGUMENTS - BEGIN
	59883	+ {
	59884	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	59885	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59886	+ }
	59887	+ // ACCUMULATE ARGUMENTS - END
	59888	+ uint64_t return_to = 18446744073709548077LLU;
	59889	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59890	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59891	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59892	+ heap.data[0].elem1 = heap.data[0].elem0;
	59893	+ heap.data[0].elem0 = restore;
	59894	+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
59598	59895	break;
59599	59896	}
59600		- case 18446744073709548103LLU: // 99999999IG'''''''''''''''
	59897	+ case 18446744073709548077LLU: // 99999999Hr'''''''''''''''
59601	59898	{
59602		- state.addr = 18446744073709548110LLU; // 99999999IN'''''''''''''''
	59899	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 22
	59900	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59901	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	59902	+ state.addr = 18446744073709548076LLU; // 99999999Hq'''''''''''''''
59603	59903	break;
59604	59904	}
59605		- case 18446744073709548110LLU: // 99999999IN'''''''''''''''
	59905	+ case 18446744073709548080LLU: // 99999999Hu'''''''''''''''
59606	59906	{
59607		- state.addr = 18446744073709548115LLU; // 99999999IS'''''''''''''''
	59907	+ // ACCUMULATE ARGUMENTS - BEGIN
	59908	+ {
	59909	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 21LLU, 0LLU);
	59910	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59911	+ }
	59912	+ {
	59913	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU), 0LLU);
	59914	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59915	+ }
	59916	+ // ACCUMULATE ARGUMENTS - END
	59917	+ uint64_t return_to = 18446744073709548074LLU;
	59918	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
	59919	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59920	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59921	+ heap.data[0].elem1 = heap.data[0].elem0;
	59922	+ heap.data[0].elem0 = restore;
	59923	+ state.addr = 517555565476695680LLU; // assertu64_
59608	59924	break;
59609	59925	}
59610		- case 18446744073709548115LLU: // 99999999IS'''''''''''''''
	59926	+ case 18446744073709548074LLU: // 99999999Ho'''''''''''''''
59611	59927	{
	59928	+ state.addr = 18446744073709548075LLU; // 99999999Hp'''''''''''''''
	59929	+ break;
	59930	+ }
	59931	+ case 18446744073709548075LLU: // 99999999Hp'''''''''''''''
	59932	+ {
	59933	+ fprintf(stdout, "%s", "\n ");
	59934	+ // ACCUMULATE ARGUMENTS - BEGIN
	59935	+ {
	59936	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 21LLU, 12LLU);
	59937	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59938	+ }
	59939	+ {
	59940	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 21LLU, 13LLU);
	59941	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59942	+ }
	59943	+ {
	59944	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 21LLU, 14LLU);
	59945	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59946	+ }
	59947	+ {
	59948	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU), 1LLU);
	59949	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59950	+ }
	59951	+ {
	59952	+ uint64_t arg = /result____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU), 2LLU);
	59953	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59954	+ }
	59955	+ // ACCUMULATE ARGUMENTS - END
	59956	+ uint64_t return_to = 18446744073709548072LLU;
	59957	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
	59958	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59959	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59960	+ heap.data[0].elem1 = heap.data[0].elem0;
	59961	+ heap.data[0].elem0 = restore;
	59962	+ state.addr = 587881357514113024LLU; // emitpar___
	59963	+ break;
	59964	+ }
	59965	+ case 18446744073709548072LLU: // 99999999Hm'''''''''''''''
	59966	+ {
	59967	+ state.addr = 18446744073709548073LLU; // 99999999Hn'''''''''''''''
	59968	+ break;
	59969	+ }
	59970	+ case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
	59971	+ {
	59972	+ fprintf(stdout, "%s", " = ");
	59973	+ {
	59974	+ uint64_t arg = 0;
	59975	+ LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
	59976	+ }
	59977	+ // ACCUMULATE ARGUMENTS - BEGIN
	59978	+ {
	59979	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	59980	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	59981	+ }
	59982	+ // ACCUMULATE ARGUMENTS - END
	59983	+ uint64_t return_to = 18446744073709548070LLU;
	59984	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	59985	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	59986	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	59987	+ heap.data[0].elem1 = heap.data[0].elem0;
	59988	+ heap.data[0].elem0 = restore;
	59989	+ state.addr = 861504796319285248LLU; // typeu64___
	59990	+ break;
	59991	+ }
	59992	+ case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
	59993	+ {
	59994	+ state.addr = 18446744073709548071LLU; // 99999999Hl'''''''''''''''
	59995	+ break;
	59996	+ }
	59997	+ case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
	59998	+ {
	59999	+ {
	60000	+ uint64_t arg = 0LLU;
	60001	+ LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/address of current closure/, &arg);
	60002	+ }
	60003	+ {
	60004	+ uint64_t arg = 0LLU;
	60005	+ LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/address of current closure/, &arg);
	60006	+ }
	60007	+ {
	60008	+ uint64_t arg = 0LLU;
	60009	+ LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/address of current closure/, &arg);
	60010	+ }
	60011	+ {
	60012	+ uint64_t arg = 0LLU;
	60013	+ LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/address of current closure/, &arg);
	60014	+ }
	60015	+ {
	60016	+ uint64_t arg = 0LLU;
	60017	+ LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/address of current closure/, &arg);
	60018	+ }
	60019	+ // ACCUMULATE ARGUMENTS - BEGIN
	60020	+ {
	60021	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU);
	60022	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60023	+ }
	60024	+ {
	60025	+ uint64_t arg = /typedefs__/*LOCAL_ACCESS(heap.data, 27LLU, 7LLU);
	60026	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60027	+ }
	60028	+ {
	60029	+ uint64_t arg = /blocklist_/*LOCAL_ACCESS(heap.data, 27LLU, 8LLU);
	60030	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60031	+ }
	60032	+ {
	60033	+ uint64_t arg = /varlist___/*LOCAL_ACCESS(heap.data, 27LLU, 9LLU);
	60034	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60035	+ }
	60036	+ {
	60037	+ uint64_t arg = /typesrc___/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 21LLU);
	60038	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60039	+ }
	60040	+ {
	60041	+ uint64_t arg = /callee_id_/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 19LLU);
	60042	+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60043	+ }
	60044	+ {
	60045	+ uint64_t arg = /c_________/*LOCAL_ACCESS(heap.data, 27LLU, 11LLU);
	60046	+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60047	+ }
	60048	+ {
	60049	+ uint64_t arg = /dstidx____/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 22LLU);
	60050	+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60051	+ }
	60052	+ {
	60053	+ uint64_t arg = /INDIRECT__/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU);
	60054	+ LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60055	+ }
	60056	+ {
	60057	+ uint64_t arg = /mutable___/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU);
	60058	+ LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60059	+ }
	60060	+ {
	60061	+ uint64_t arg = /parameter_/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 25LLU);
	60062	+ LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60063	+ }
	60064	+ {
	60065	+ uint64_t arg = /initialize/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 26LLU);
	60066	+ LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60067	+ }
	60068	+ {
	60069	+ uint64_t arg = /defargcnt_/*LOCAL_ACCESS(heap.data, 27LLU, 12LLU);
	60070	+ LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60071	+ }
	60072	+ {
	60073	+ uint64_t arg = /defbodysz_/*LOCAL_ACCESS(heap.data, 27LLU, 13LLU);
	60074	+ LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60075	+ }
	60076	+ {
	60077	+ uint64_t arg = /remainsize/*LOCAL_ACCESS(heap.data, 27LLU, 14LLU);
	60078	+ LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60079	+ }
	60080	+ // ACCUMULATE ARGUMENTS - END
	60081	+ uint64_t return_to = 18446744073709548068LLU;
	60082	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
	60083	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	60084	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	60085	+ heap.data[0].elem1 = heap.data[0].elem0;
	60086	+ heap.data[0].elem0 = restore;
	60087	+ state.addr = 787472342492567585LLU; // procvarref
	60088	+ break;
	60089	+ }
	60090	+ case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
	60091	+ {
	60092	+ state.addr = 18446744073709548069LLU; // 99999999Hj'''''''''''''''
	60093	+ break;
	60094	+ }
	60095	+ case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
	60096	+ {
	60097	+ fprintf(stdout, "%s", ";");
	60098	+ ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 27LLU, 11LLU)), stdin);
	60099	+ if(';' != (char)getchar())
	60100	+ {
	60101	+ fprintf(stderr, "match failed at char %c\n", (char)59LLU);
	60102	+ exit(-1);
	60103	+ }
	60104	+ // variable u64 initialize goes out of scope
	60105	+ // emitted destructur for type u64
	60106	+ (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference initialize at 27
	60107	+ // variable u64 parameter_ goes out of scope
	60108	+ // emitted destructur for type u64
	60109	+ (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parameter_ at 26
	60110	+ // variable u64 mutable___ goes out of scope
	60111	+ // emitted destructur for type u64
	60112	+ (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 25
	60113	+ // variable u64 INDIRECT__ goes out of scope
	60114	+ // emitted destructur for type u64
	60115	+ (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 24
	60116	+ // variable u64 dstidx____ goes out of scope
	60117	+ // emitted destructur for type u64
	60118	+ (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dstidx____ at 23
	60119	+ // variable type______ typesrc___ goes out of scope
	60120	+ // emitted destructur for type type______
	60121	+ // ACCUMULATE ARGUMENTS - BEGIN
	60122	+ {
	60123	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU);
	60124	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60125	+ }
	60126	+ // ACCUMULATE ARGUMENTS - END
	60127	+ uint64_t return_to = 18446744073709548067LLU;
	60128	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	60129	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	60130	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	60131	+ heap.data[0].elem1 = heap.data[0].elem0;
	60132	+ heap.data[0].elem0 = restore;
	60133	+ state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
	60134	+ break;
	60135	+ }
	60136	+ case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
	60137	+ {
	60138	+ (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typesrc___ at 22
	60139	+ state.addr = 18446744073709548076LLU; // 99999999Hq'''''''''''''''
	60140	+ break;
	60141	+ }
	60142	+ case 18446744073709548076LLU: // 99999999Hq'''''''''''''''
	60143	+ {
	60144	+ // variable resdest___ result____ goes out of scope
	60145	+ // emitted destructur for type resdest___
	60146	+ // ACCUMULATE ARGUMENTS - BEGIN
	60147	+ {
	60148	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU);
	60149	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60150	+ }
	60151	+ // ACCUMULATE ARGUMENTS - END
	60152	+ uint64_t return_to = 18446744073709548066LLU;
	60153	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	60154	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	60155	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	60156	+ heap.data[0].elem1 = heap.data[0].elem0;
	60157	+ heap.data[0].elem0 = restore;
	60158	+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
	60159	+ break;
	60160	+ }
	60161	+ case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
	60162	+ {
	60163	+ (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 21
	60164	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	60165	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	60166	+ state.addr = 18446744073709548065LLU; // 99999999Hf'''''''''''''''
	60167	+ break;
	60168	+ }
	60169	+ case 18446744073709548082LLU: // 99999999Hw'''''''''''''''
	60170	+ {
	60171	+ // ACCUMULATE ARGUMENTS - BEGIN
	60172	+ {
	60173	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 20LLU, 0LLU);
	60174	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	60175	+ }
	60176	+ // ACCUMULATE ARGUMENTS - END
	60177	+ uint64_t return_to = 18446744073709548063LLU;
	60178	+ const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
	60179	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	60180	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	60181	+ heap.data[0].elem1 = heap.data[0].elem0;
	60182	+ heap.data[0].elem0 = restore;
	60183	+ state.addr = 819847183515949359LLU; // reportinit
	60184	+ break;
	60185	+ }
	60186	+ case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
	60187	+ {
	60188	+ state.addr = 18446744073709548064LLU; // 99999999He'''''''''''''''
	60189	+ break;
	60190	+ }
	60191	+ case 18446744073709548064LLU: // 99999999He'''''''''''''''
	60192	+ {
	60193	+ fprintf(stderr, "%s", "missing result in assignment from ");
	60194	+ printid(stderr, /callee_id_/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU));
	60195	+ {
	60196	+ fprintf(stderr, "%s\n", "");
	60197	+ exit(-1);
	60198	+ }
	60199	+ state.addr = 18446744073709548065LLU; // 99999999Hf'''''''''''''''
	60200	+ break;
	60201	+ }
	60202	+ case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
	60203	+ {
	60204	+ state.addr = 18446744073709548084LLU; // 99999999Hy'''''''''''''''
	60205	+ break;
	60206	+ }
	60207	+ case 18446744073709548084LLU: // 99999999Hy'''''''''''''''
	60208	+ {
	60209	+ state.addr = 18446744073709548091LLU; // 99999999H5'''''''''''''''
	60210	+ break;
	60211	+ }
	60212	+ case 18446744073709548091LLU: // 99999999H5'''''''''''''''
	60213	+ {
	60214	+ state.addr = 18446744073709548096LLU; // 99999999I_'''''''''''''''
	60215	+ break;
	60216	+ }
	60217	+ case 18446744073709548096LLU: // 99999999I_'''''''''''''''
	60218	+ {
	60219	+ state.addr = 18446744073709548101LLU; // 99999999IE'''''''''''''''
	60220	+ break;
	60221	+ }
	60222	+ case 18446744073709548101LLU: // 99999999IE'''''''''''''''
	60223	+ {
59612	60224	// variable u64 callee_id_ goes out of scope
59613	60225	// emitted destructur for type u64
59614	60226	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference callee_id_ at 20

		@@ -59677,7 +60289,7 @@
59677	60289	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59678	60290	}
59679	60291	// ACCUMULATE ARGUMENTS - END
59680		- uint64_t return_to = 18446744073709548101LLU;
	60292	+ uint64_t return_to = 18446744073709548061LLU;
59681	60293	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
59682	60294	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59683	60295	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59686,12 +60298,12 @@
59686	60298	state.addr = 861504796319285248LLU; // typeu64___
59687	60299	break;
59688	60300	}
59689		- case 18446744073709548101LLU: // 99999999IE'''''''''''''''
	60301	+ case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
59690	60302	{
59691		- state.addr = 18446744073709548102LLU; // 99999999IF'''''''''''''''
	60303	+ state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
59692	60304	break;
59693	60305	}
59694		- case 18446744073709548102LLU: // 99999999IF'''''''''''''''
	60306	+ case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
59695	60307	{
59696	60308	{
59697	60309	uint64_t arg = 0LLU;

		@@ -59771,7 +60383,7 @@
59771	60383	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59772	60384	}
59773	60385	// ACCUMULATE ARGUMENTS - END
59774		- uint64_t return_to = 18446744073709548097LLU;
	60386	+ uint64_t return_to = 18446744073709548057LLU;
59775	60387	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
59776	60388	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59777	60389	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59780,12 +60392,12 @@
59780	60392	state.addr = 604790753280317473LLU; // findvarref
59781	60393	break;
59782	60394	}
59783		- case 18446744073709548097LLU: // 99999999IA'''''''''''''''
	60395	+ case 18446744073709548057LLU: // 99999999HY'''''''''''''''
59784	60396	{
59785		- state.addr = 18446744073709548098LLU; // 99999999IB'''''''''''''''
	60397	+ state.addr = 18446744073709548058LLU; // 99999999HZ'''''''''''''''
59786	60398	break;
59787	60399	}
59788		- case 18446744073709548098LLU: // 99999999IB'''''''''''''''
	60400	+ case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
59789	60401	{
59790	60402	// variable u64 consume___ goes out of scope
59791	60403	// emitted destructur for type u64

		@@ -59793,25 +60405,25 @@
59793	60405	// variable u64 optelem___ goes out of scope
59794	60406	// emitted destructur for type u64
59795	60407	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference optelem___ at 20
59796		- state.addr = 18446744073709548099LLU; // 99999999IC'''''''''''''''
	60408	+ state.addr = 18446744073709548059LLU; // 99999999H$'''''''''''''''
59797	60409	break;
59798	60410	}
59799		- case 18446744073709548099LLU: // 99999999IC'''''''''''''''
	60411	+ case 18446744073709548059LLU: // 99999999H$'''''''''''''''
59800	60412	{
59801		- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548096LLU : 18446744073709548095LLU;
	60413	+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548056LLU : 18446744073709548055LLU;
59802	60414	break;
59803	60415	}
59804		- case 18446744073709548096LLU: // 99999999I_'''''''''''''''
	60416	+ case 18446744073709548056LLU: // 99999999HX'''''''''''''''
59805	60417	{
59806		- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548094LLU : 18446744073709548093LLU;
	60418	+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 17LLU) ? 18446744073709548054LLU : 18446744073709548053LLU;
59807	60419	break;
59808	60420	}
59809		- case 18446744073709548094LLU: // 99999999H8'''''''''''''''
	60421	+ case 18446744073709548054LLU: // 99999999HV'''''''''''''''
59810	60422	{
59811		- state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548092LLU : 18446744073709548091LLU;
	60423	+ state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548052LLU : 18446744073709548051LLU;
59812	60424	break;
59813	60425	}
59814		- case 18446744073709548092LLU: // 99999999H6'''''''''''''''
	60426	+ case 18446744073709548052LLU: // 99999999HT'''''''''''''''
59815	60427	{
59816	60428	{
59817	60429	uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/addr-content-pair/, LOCAL_ACCESS_ADDR(heap.data, 19LLU, 13LLU), 1/content/), 0LLU);

		@@ -59835,7 +60447,7 @@
59835	60447	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59836	60448	}
59837	60449	// ACCUMULATE ARGUMENTS - END
59838		- uint64_t return_to = 18446744073709548089LLU;
	60450	+ uint64_t return_to = 18446744073709548049LLU;
59839	60451	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
59840	60452	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59841	60453	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59844,12 +60456,12 @@
59844	60456	state.addr = 861504788261634048LLU; // typename__
59845	60457	break;
59846	60458	}
59847		- case 18446744073709548089LLU: // 99999999H3'''''''''''''''
	60459	+ case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
59848	60460	{
59849		- state.addr = 18446744073709548090LLU; // 99999999H4'''''''''''''''
	60461	+ state.addr = 18446744073709548050LLU; // 99999999HR'''''''''''''''
59850	60462	break;
59851	60463	}
59852		- case 18446744073709548090LLU: // 99999999H4'''''''''''''''
	60464	+ case 18446744073709548050LLU: // 99999999HR'''''''''''''''
59853	60465	{
59854	60466	// ACCUMULATE ARGUMENTS - BEGIN
59855	60467	{

		@@ -59889,7 +60501,7 @@
59889	60501	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59890	60502	}
59891	60503	// ACCUMULATE ARGUMENTS - END
59892		- uint64_t return_to = 18446744073709548087LLU;
	60504	+ uint64_t return_to = 18446744073709548047LLU;
59893	60505	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
59894	60506	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59895	60507	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59898,12 +60510,12 @@
59898	60510	state.addr = 587881344696777536LLU; // emitdestr_
59899	60511	break;
59900	60512	}
59901		- case 18446744073709548087LLU: // 99999999H1'''''''''''''''
	60513	+ case 18446744073709548047LLU: // 99999999HO'''''''''''''''
59902	60514	{
59903		- state.addr = 18446744073709548088LLU; // 99999999H2'''''''''''''''
	60515	+ state.addr = 18446744073709548048LLU; // 99999999HP'''''''''''''''
59904	60516	break;
59905	60517	}
59906		- case 18446744073709548088LLU: // 99999999H2'''''''''''''''
	60518	+ case 18446744073709548048LLU: // 99999999HP'''''''''''''''
59907	60519	{
59908	60520	// variable type______ TYPEDST___ goes out of scope
59909	60521	// emitted destructur for type type______

		@@ -59913,7 +60525,7 @@
59913	60525	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59914	60526	}
59915	60527	// ACCUMULATE ARGUMENTS - END
59916		- uint64_t return_to = 18446744073709548086LLU;
	60528	+ uint64_t return_to = 18446744073709548046LLU;
59917	60529	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
59918	60530	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59919	60531	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59922,7 +60534,7 @@
59922	60534	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
59923	60535	break;
59924	60536	}
59925		- case 18446744073709548086LLU: // 99999999H0'''''''''''''''
	60537	+ case 18446744073709548046LLU: // 99999999HN'''''''''''''''
59926	60538	{
59927	60539	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPEDST___ at 22
59928	60540	// variable u64 name______ goes out of scope

		@@ -59932,22 +60544,22 @@
59932	60544	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference name______ at 20
59933	60545	heap.availilable_size_for_dynamic_objects += 0LLU;
59934	60546	heap.availilable_size_for_dynamic_objects += 0LLU;
59935		- state.addr = 18446744073709548085LLU; // 99999999Hz'''''''''''''''
	60547	+ state.addr = 18446744073709548045LLU; // 99999999HM'''''''''''''''
59936	60548	break;
59937	60549	}
59938		- case 18446744073709548091LLU: // 99999999H5'''''''''''''''
	60550	+ case 18446744073709548051LLU: // 99999999HS'''''''''''''''
59939	60551	{
59940		- state.addr = 18446744073709548085LLU; // 99999999Hz'''''''''''''''
	60552	+ state.addr = 18446744073709548045LLU; // 99999999HM'''''''''''''''
59941	60553	break;
59942	60554	}
59943		- case 18446744073709548085LLU: // 99999999Hz'''''''''''''''
	60555	+ case 18446744073709548045LLU: // 99999999HM'''''''''''''''
59944	60556	{
59945	60557	heap.availilable_size_for_dynamic_objects += 0LLU;
59946	60558	heap.availilable_size_for_dynamic_objects += 0LLU;
59947		- state.addr = 18446744073709548084LLU; // 99999999Hy'''''''''''''''
	60559	+ state.addr = 18446744073709548044LLU; // 99999999HL'''''''''''''''
59948	60560	break;
59949	60561	}
59950		- case 18446744073709548093LLU: // 99999999H7'''''''''''''''
	60562	+ case 18446744073709548053LLU: // 99999999HU'''''''''''''''
59951	60563	{
59952	60564	fprintf(stderr, "%s", "cannot assign to constant ");
59953	60565	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -59956,7 +60568,7 @@
59956	60568	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
59957	60569	}
59958	60570	// ACCUMULATE ARGUMENTS - END
59959		- uint64_t return_to = 18446744073709548082LLU;
	60571	+ uint64_t return_to = 18446744073709548042LLU;
59960	60572	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
59961	60573	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
59962	60574	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -59965,12 +60577,12 @@
59965	60577	state.addr = 819847183518878432LLU; // reporttype
59966	60578	break;
59967	60579	}
59968		- case 18446744073709548082LLU: // 99999999Hw'''''''''''''''
	60580	+ case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
59969	60581	{
59970		- state.addr = 18446744073709548083LLU; // 99999999Hx'''''''''''''''
	60582	+ state.addr = 18446744073709548043LLU; // 99999999HK'''''''''''''''
59971	60583	break;
59972	60584	}
59973		- case 18446744073709548083LLU: // 99999999Hx'''''''''''''''
	60585	+ case 18446744073709548043LLU: // 99999999HK'''''''''''''''
59974	60586	{
59975	60587	fprintf(stderr, "%s", " ");
59976	60588	printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));

		@@ -59978,17 +60590,17 @@
59978	60590	fprintf(stderr, "%s\n", "");
59979	60591	exit(-1);
59980	60592	}
59981		- state.addr = 18446744073709548084LLU; // 99999999Hy'''''''''''''''
	60593	+ state.addr = 18446744073709548044LLU; // 99999999HL'''''''''''''''
59982	60594	break;
59983	60595	}
59984		- case 18446744073709548084LLU: // 99999999Hy'''''''''''''''
	60596	+ case 18446744073709548044LLU: // 99999999HL'''''''''''''''
59985	60597	{
59986	60598	heap.availilable_size_for_dynamic_objects += 0LLU;
59987	60599	heap.availilable_size_for_dynamic_objects += 0LLU;
59988		- state.addr = 18446744073709548081LLU; // 99999999Hv'''''''''''''''
	60600	+ state.addr = 18446744073709548041LLU; // 99999999HI'''''''''''''''
59989	60601	break;
59990	60602	}
59991		- case 18446744073709548095LLU: // 99999999H9'''''''''''''''
	60603	+ case 18446744073709548055LLU: // 99999999HW'''''''''''''''
59992	60604	{
59993	60605	// ACCUMULATE ARGUMENTS - BEGIN
59994	60606	{

		@@ -60008,7 +60620,7 @@
60008	60620	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60009	60621	}
60010	60622	// ACCUMULATE ARGUMENTS - END
60011		- uint64_t return_to = 18446744073709548079LLU;
	60623	+ uint64_t return_to = 18446744073709548039LLU;
60012	60624	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
60013	60625	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60014	60626	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60017,17 +60629,17 @@
60017	60629	state.addr = 660220432971388961LLU; // initvarref
60018	60630	break;
60019	60631	}
60020		- case 18446744073709548079LLU: // 99999999Ht'''''''''''''''
	60632	+ case 18446744073709548039LLU: // 99999999HG'''''''''''''''
60021	60633	{
60022		- state.addr = 18446744073709548080LLU; // 99999999Hu'''''''''''''''
	60634	+ state.addr = 18446744073709548040LLU; // 99999999HH'''''''''''''''
60023	60635	break;
60024	60636	}
60025		- case 18446744073709548080LLU: // 99999999Hu'''''''''''''''
	60637	+ case 18446744073709548040LLU: // 99999999HH'''''''''''''''
60026	60638	{
60027		- state.addr = 18446744073709548081LLU; // 99999999Hv'''''''''''''''
	60639	+ state.addr = 18446744073709548041LLU; // 99999999HI'''''''''''''''
60028	60640	break;
60029	60641	}
60030		- case 18446744073709548081LLU: // 99999999Hv'''''''''''''''
	60642	+ case 18446744073709548041LLU: // 99999999HI'''''''''''''''
60031	60643	{
60032	60644	// variable u64 parameter_ goes out of scope
60033	60645	// emitted destructur for type u64

		@@ -60035,10 +60647,10 @@
60035	60647	// variable u64 mutable___ goes out of scope
60036	60648	// emitted destructur for type u64
60037	60649	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference mutable___ at 18
60038		- state.addr = 18446744073709548100LLU; // 99999999ID'''''''''''''''
	60650	+ state.addr = 18446744073709548060LLU; // 99999999Ha'''''''''''''''
60039	60651	break;
60040	60652	}
60041		- case 18446744073709548100LLU: // 99999999ID'''''''''''''''
	60653	+ case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
60042	60654	{
60043	60655	// ACCUMULATE ARGUMENTS - BEGIN
60044	60656	{

		@@ -60046,7 +60658,7 @@
60046	60658	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60047	60659	}
60048	60660	// ACCUMULATE ARGUMENTS - END
60049		- uint64_t return_to = 18446744073709548077LLU;
	60661	+ uint64_t return_to = 18446744073709548037LLU;
60050	60662	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60051	60663	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60052	60664	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60055,12 +60667,12 @@
60055	60667	state.addr = 839519719621918720LLU; // skipws____
60056	60668	break;
60057	60669	}
60058		- case 18446744073709548077LLU: // 99999999Hr'''''''''''''''
	60670	+ case 18446744073709548037LLU: // 99999999HE'''''''''''''''
60059	60671	{
60060		- state.addr = 18446744073709548078LLU; // 99999999Hs'''''''''''''''
	60672	+ state.addr = 18446744073709548038LLU; // 99999999HF'''''''''''''''
60061	60673	break;
60062	60674	}
60063		- case 18446744073709548078LLU: // 99999999Hs'''''''''''''''
	60675	+ case 18446744073709548038LLU: // 99999999HF'''''''''''''''
60064	60676	{
60065	60677	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 17LLU, 8LLU)));
60066	60678	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -60069,7 +60681,7 @@
60069	60681	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60070	60682	}
60071	60683	// ACCUMULATE ARGUMENTS - END
60072		- uint64_t return_to = 18446744073709548075LLU;
	60684	+ uint64_t return_to = 18446744073709548035LLU;
60073	60685	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60074	60686	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60075	60687	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60078,12 +60690,12 @@
60078	60690	state.addr = 839519719621918720LLU; // skipws____
60079	60691	break;
60080	60692	}
60081		- case 18446744073709548075LLU: // 99999999Hp'''''''''''''''
	60693	+ case 18446744073709548035LLU: // 99999999HC'''''''''''''''
60082	60694	{
60083		- state.addr = 18446744073709548076LLU; // 99999999Hq'''''''''''''''
	60695	+ state.addr = 18446744073709548036LLU; // 99999999HD'''''''''''''''
60084	60696	break;
60085	60697	}
60086		- case 18446744073709548076LLU: // 99999999Hq'''''''''''''''
	60698	+ case 18446744073709548036LLU: // 99999999HD'''''''''''''''
60087	60699	{
60088	60700	{
60089	60701	uint64_t arg = 59LLU;

		@@ -60107,7 +60719,7 @@
60107	60719	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60108	60720	}
60109	60721	// ACCUMULATE ARGUMENTS - END
60110		- uint64_t return_to = 18446744073709548073LLU;
	60722	+ uint64_t return_to = 18446744073709548033LLU;
60111	60723	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
60112	60724	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60113	60725	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60116,17 +60728,17 @@
60116	60728	state.addr = 728666047794575267LLU; // matchoptch
60117	60729	break;
60118	60730	}
60119		- case 18446744073709548073LLU: // 99999999Hn'''''''''''''''
	60731	+ case 18446744073709548033LLU: // 99999999HA'''''''''''''''
60120	60732	{
60121		- state.addr = 18446744073709548074LLU; // 99999999Ho'''''''''''''''
	60733	+ state.addr = 18446744073709548034LLU; // 99999999HB'''''''''''''''
60122	60734	break;
60123	60735	}
60124		- case 18446744073709548074LLU: // 99999999Ho'''''''''''''''
	60736	+ case 18446744073709548034LLU: // 99999999HB'''''''''''''''
60125	60737	{
60126		- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548072LLU : 18446744073709548071LLU;
	60738	+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709548032LLU : 18446744073709548031LLU;
60127	60739	break;
60128	60740	}
60129		- case 18446744073709548072LLU: // 99999999Hm'''''''''''''''
	60741	+ case 18446744073709548032LLU: // 99999999H_'''''''''''''''
60130	60742	{
60131	60743	// ACCUMULATE ARGUMENTS - BEGIN
60132	60744	{

		@@ -60138,7 +60750,7 @@
60138	60750	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60139	60751	}
60140	60752	// ACCUMULATE ARGUMENTS - END
60141		- uint64_t return_to = 18446744073709548069LLU;
	60753	+ uint64_t return_to = 18446744073709548029LLU;
60142	60754	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
60143	60755	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60144	60756	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60147,17 +60759,17 @@
60147	60759	state.addr = 517555565476695680LLU; // assertu64_
60148	60760	break;
60149	60761	}
60150		- case 18446744073709548069LLU: // 99999999Hj'''''''''''''''
	60762	+ case 18446744073709548029LLU: // 99999999G7'''''''''''''''
60151	60763	{
60152		- state.addr = 18446744073709548070LLU; // 99999999Hk'''''''''''''''
	60764	+ state.addr = 18446744073709548030LLU; // 99999999G8'''''''''''''''
60153	60765	break;
60154	60766	}
60155		- case 18446744073709548070LLU: // 99999999Hk'''''''''''''''
	60767	+ case 18446744073709548030LLU: // 99999999G8'''''''''''''''
60156	60768	{
60157		- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548068LLU : 18446744073709548067LLU;
	60769	+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) ? 18446744073709548028LLU : 18446744073709548027LLU;
60158	60770	break;
60159	60771	}
60160		- case 18446744073709548068LLU: // 99999999Hi'''''''''''''''
	60772	+ case 18446744073709548028LLU: // 99999999G6'''''''''''''''
60161	60773	{
60162	60774	fprintf(stdout, "%s", "\n ");
60163	60775	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -60182,7 +60794,7 @@
60182	60794	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60183	60795	}
60184	60796	// ACCUMULATE ARGUMENTS - END
60185		- uint64_t return_to = 18446744073709548065LLU;
	60797	+ uint64_t return_to = 18446744073709548025LLU;
60186	60798	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
60187	60799	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60188	60800	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60191,12 +60803,12 @@
60191	60803	state.addr = 587881357514113024LLU; // emitpar___
60192	60804	break;
60193	60805	}
60194		- case 18446744073709548065LLU: // 99999999Hf'''''''''''''''
	60806	+ case 18446744073709548025LLU: // 99999999G3'''''''''''''''
60195	60807	{
60196		- state.addr = 18446744073709548066LLU; // 99999999Hg'''''''''''''''
	60808	+ state.addr = 18446744073709548026LLU; // 99999999G4'''''''''''''''
60197	60809	break;
60198	60810	}
60199		- case 18446744073709548066LLU: // 99999999Hg'''''''''''''''
	60811	+ case 18446744073709548026LLU: // 99999999G4'''''''''''''''
60200	60812	{
60201	60813	fprintf(stdout, "%s", " = 0;");
60202	60814	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -60217,7 +60829,7 @@
60217	60829	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60218	60830	}
60219	60831	// ACCUMULATE ARGUMENTS - END
60220		- uint64_t return_to = 18446744073709548063LLU;
	60832	+ uint64_t return_to = 18446744073709548023LLU;
60221	60833	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
60222	60834	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60223	60835	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60226,31 +60838,31 @@
60226	60838	state.addr = 732615645798520865LLU; // movevarref
60227	60839	break;
60228	60840	}
60229		- case 18446744073709548063LLU: // 99999999Hd'''''''''''''''
	60841	+ case 18446744073709548023LLU: // 99999999G1'''''''''''''''
60230	60842	{
60231		- state.addr = 18446744073709548064LLU; // 99999999He'''''''''''''''
	60843	+ state.addr = 18446744073709548024LLU; // 99999999G2'''''''''''''''
60232	60844	break;
60233	60845	}
60234		- case 18446744073709548064LLU: // 99999999He'''''''''''''''
	60846	+ case 18446744073709548024LLU: // 99999999G2'''''''''''''''
60235	60847	{
60236	60848	heap.availilable_size_for_dynamic_objects += 0LLU;
60237	60849	heap.availilable_size_for_dynamic_objects += 0LLU;
60238		- state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
	60850	+ state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
60239	60851	break;
60240	60852	}
60241		- case 18446744073709548067LLU: // 99999999Hh'''''''''''''''
	60853	+ case 18446744073709548027LLU: // 99999999G5'''''''''''''''
60242	60854	{
60243		- state.addr = 18446744073709548062LLU; // 99999999Hc'''''''''''''''
	60855	+ state.addr = 18446744073709548022LLU; // 99999999G0'''''''''''''''
60244	60856	break;
60245	60857	}
60246		- case 18446744073709548062LLU: // 99999999Hc'''''''''''''''
	60858	+ case 18446744073709548022LLU: // 99999999G0'''''''''''''''
60247	60859	{
60248	60860	heap.availilable_size_for_dynamic_objects += 0LLU;
60249	60861	heap.availilable_size_for_dynamic_objects += 0LLU;
60250		- state.addr = 18446744073709548061LLU; // 99999999Hb'''''''''''''''
	60862	+ state.addr = 18446744073709548021LLU; // 99999999Gz'''''''''''''''
60251	60863	break;
60252	60864	}
60253		- case 18446744073709548071LLU: // 99999999Hl'''''''''''''''
	60865	+ case 18446744073709548031LLU: // 99999999G9'''''''''''''''
60254	60866	{
60255	60867	{
60256	60868	uint64_t arg = 0;

		@@ -60266,7 +60878,7 @@
60266	60878	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60267	60879	}
60268	60880	// ACCUMULATE ARGUMENTS - END
60269		- uint64_t return_to = 18446744073709548057LLU;
	60881	+ uint64_t return_to = 18446744073709548017LLU;
60270	60882	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
60271	60883	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60272	60884	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60275,23 +60887,23 @@
60275	60887	state.addr = 661605045736570880LLU; // isdigit___
60276	60888	break;
60277	60889	}
60278		- case 18446744073709548057LLU: // 99999999HY'''''''''''''''
	60890	+ case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
60279	60891	{
60280		- state.addr = 18446744073709548058LLU; // 99999999HZ'''''''''''''''
	60892	+ state.addr = 18446744073709548018LLU; // 99999999Gw'''''''''''''''
60281	60893	break;
60282	60894	}
60283		- case 18446744073709548058LLU: // 99999999HZ'''''''''''''''
	60895	+ case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
60284	60896	{
60285		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548060LLU : 18446744073709548059LLU;
	60897	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548020LLU : 18446744073709548019LLU;
60286	60898	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 20
60287	60899	break;
60288	60900	}
60289		- case 18446744073709548060LLU: // 99999999Ha'''''''''''''''
	60901	+ case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
60290	60902	{
60291		- state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548056LLU : 18446744073709548055LLU;
	60903	+ state.addr = 0LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548016LLU : 18446744073709548015LLU;
60292	60904	break;
60293	60905	}
60294		- case 18446744073709548056LLU: // 99999999HX'''''''''''''''
	60906	+ case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
60295	60907	{
60296	60908	// ACCUMULATE ARGUMENTS - BEGIN
60297	60909	{

		@@ -60315,7 +60927,7 @@
60315	60927	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60316	60928	}
60317	60929	// ACCUMULATE ARGUMENTS - END
60318		- uint64_t return_to = 18446744073709548053LLU;
	60930	+ uint64_t return_to = 18446744073709548013LLU;
60319	60931	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
60320	60932	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60321	60933	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60324,12 +60936,12 @@
60324	60936	state.addr = 587881357514113024LLU; // emitpar___
60325	60937	break;
60326	60938	}
60327		- case 18446744073709548053LLU: // 99999999HU'''''''''''''''
	60939	+ case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
60328	60940	{
60329		- state.addr = 18446744073709548054LLU; // 99999999HV'''''''''''''''
	60941	+ state.addr = 18446744073709548014LLU; // 99999999Gs'''''''''''''''
60330	60942	break;
60331	60943	}
60332		- case 18446744073709548054LLU: // 99999999HV'''''''''''''''
	60944	+ case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
60333	60945	{
60334	60946	fprintf(stdout, "%s", " = ");
60335	60947	{

		@@ -60343,7 +60955,7 @@
60343	60955	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60344	60956	}
60345	60957	// ACCUMULATE ARGUMENTS - END
60346		- uint64_t return_to = 18446744073709548051LLU;
	60958	+ uint64_t return_to = 18446744073709548011LLU;
60347	60959	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60348	60960	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60349	60961	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60352,12 +60964,12 @@
60352	60964	state.addr = 787446708198178816LLU; // printnr___
60353	60965	break;
60354	60966	}
60355		- case 18446744073709548051LLU: // 99999999HS'''''''''''''''
	60967	+ case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
60356	60968	{
60357		- state.addr = 18446744073709548052LLU; // 99999999HT'''''''''''''''
	60969	+ state.addr = 18446744073709548012LLU; // 99999999Gq'''''''''''''''
60358	60970	break;
60359	60971	}
60360		- case 18446744073709548052LLU: // 99999999HT'''''''''''''''
	60972	+ case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
60361	60973	{
60362	60974	fprintf(stdout, "%s", ";\n");
60363	60975	// variable u64 nr________ goes out of scope

		@@ -60365,10 +60977,10 @@
60365	60977	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 20
60366	60978	heap.availilable_size_for_dynamic_objects += 0LLU;
60367	60979	heap.availilable_size_for_dynamic_objects += 0LLU;
60368		- state.addr = 18446744073709548050LLU; // 99999999HR'''''''''''''''
	60980	+ state.addr = 18446744073709548010LLU; // 99999999Go'''''''''''''''
60369	60981	break;
60370	60982	}
60371		- case 18446744073709548055LLU: // 99999999HW'''''''''''''''
	60983	+ case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
60372	60984	{
60373	60985	{
60374	60986	uint64_t arg = 0LLU;

		@@ -60375,10 +60987,10 @@
60375	60987	LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/address of current closure/, &arg);
60376	60988	}
60377	60989	/nr________/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 8LLU)));
60378		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548049LLU : 18446744073709548048LLU;
	60990	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709548009LLU : 18446744073709548008LLU;
60379	60991	break;
60380	60992	}
60381		- case 18446744073709548049LLU: // 99999999HQ'''''''''''''''
	60993	+ case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
60382	60994	{
60383	60995	// ACCUMULATE ARGUMENTS - BEGIN
60384	60996	{

		@@ -60390,7 +61002,7 @@
60390	61002	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60391	61003	}
60392	61004	// ACCUMULATE ARGUMENTS - END
60393		- uint64_t return_to = 18446744073709548046LLU;
	61005	+ uint64_t return_to = 18446744073709548006LLU;
60394	61006	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
60395	61007	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60396	61008	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60399,22 +61011,22 @@
60399	61011	state.addr = 517555565476695680LLU; // assertu64_
60400	61012	break;
60401	61013	}
60402		- case 18446744073709548046LLU: // 99999999HN'''''''''''''''
	61014	+ case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
60403	61015	{
60404		- state.addr = 18446744073709548047LLU; // 99999999HO'''''''''''''''
	61016	+ state.addr = 18446744073709548007LLU; // 99999999Gl'''''''''''''''
60405	61017	break;
60406	61018	}
60407		- case 18446744073709548047LLU: // 99999999HO'''''''''''''''
	61019	+ case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
60408	61020	{
60409		- state.addr = 18446744073709548048LLU; // 99999999HP'''''''''''''''
	61021	+ state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
60410	61022	break;
60411	61023	}
60412		- case 18446744073709548048LLU: // 99999999HP'''''''''''''''
	61024	+ case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
60413	61025	{
60414		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548045LLU : 18446744073709548044LLU;
	61026	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 16LLU) ? 18446744073709548005LLU : 18446744073709548004LLU;
60415	61027	break;
60416	61028	}
60417		- case 18446744073709548045LLU: // 99999999HM'''''''''''''''
	61029	+ case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
60418	61030	{
60419	61031	// ACCUMULATE ARGUMENTS - BEGIN
60420	61032	{

		@@ -60434,7 +61046,7 @@
60434	61046	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60435	61047	}
60436	61048	// ACCUMULATE ARGUMENTS - END
60437		- uint64_t return_to = 18446744073709548042LLU;
	61049	+ uint64_t return_to = 18446744073709548002LLU;
60438	61050	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
60439	61051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60440	61052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60443,44 +61055,44 @@
60443	61055	state.addr = 732615645798520865LLU; // movevarref
60444	61056	break;
60445	61057	}
60446		- case 18446744073709548042LLU: // 99999999HJ'''''''''''''''
	61058	+ case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
60447	61059	{
60448		- state.addr = 18446744073709548043LLU; // 99999999HK'''''''''''''''
	61060	+ state.addr = 18446744073709548003LLU; // 99999999Gh'''''''''''''''
60449	61061	break;
60450	61062	}
60451		- case 18446744073709548043LLU: // 99999999HK'''''''''''''''
	61063	+ case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
60452	61064	{
60453	61065	heap.availilable_size_for_dynamic_objects += 0LLU;
60454	61066	heap.availilable_size_for_dynamic_objects += 0LLU;
60455		- state.addr = 18446744073709548041LLU; // 99999999HI'''''''''''''''
	61067	+ state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
60456	61068	break;
60457	61069	}
60458		- case 18446744073709548044LLU: // 99999999HL'''''''''''''''
	61070	+ case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
60459	61071	{
60460		- state.addr = 18446744073709548041LLU; // 99999999HI'''''''''''''''
	61072	+ state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
60461	61073	break;
60462	61074	}
60463		- case 18446744073709548041LLU: // 99999999HI'''''''''''''''
	61075	+ case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
60464	61076	{
60465	61077	// variable u64 nr________ goes out of scope
60466	61078	// emitted destructur for type u64
60467	61079	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference nr________ at 20
60468		- state.addr = 18446744073709548050LLU; // 99999999HR'''''''''''''''
	61080	+ state.addr = 18446744073709548010LLU; // 99999999Go'''''''''''''''
60469	61081	break;
60470	61082	}
60471		- case 18446744073709548050LLU: // 99999999HR'''''''''''''''
	61083	+ case 18446744073709548010LLU: // 99999999Go'''''''''''''''
60472	61084	{
60473	61085	heap.availilable_size_for_dynamic_objects += 0LLU;
60474	61086	heap.availilable_size_for_dynamic_objects += 0LLU;
60475		- state.addr = 18446744073709548040LLU; // 99999999HH'''''''''''''''
	61087	+ state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
60476	61088	break;
60477	61089	}
60478		- case 18446744073709548059LLU: // 99999999H$'''''''''''''''
	61090	+ case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
60479	61091	{
60480		- state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709548039LLU : 18446744073709548038LLU;
	61092	+ state.addr = 2LLU == heap.data[*LOCAL_ACCESS(heap.data, 19LLU, 13LLU)].elem0 ? 18446744073709547999LLU : 18446744073709547998LLU;
60481	61093	break;
60482	61094	}
60483		- case 18446744073709548039LLU: // 99999999HG'''''''''''''''
	61095	+ case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
60484	61096	{
60485	61097	// ACCUMULATE ARGUMENTS - BEGIN
60486	61098	{

		@@ -60488,7 +61100,7 @@
60488	61100	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60489	61101	}
60490	61102	// ACCUMULATE ARGUMENTS - END
60491		- uint64_t return_to = 18446744073709548036LLU;
	61103	+ uint64_t return_to = 18446744073709547996LLU;
60492	61104	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60493	61105	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60494	61106	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60497,12 +61109,12 @@
60497	61109	state.addr = 819847183515949359LLU; // reportinit
60498	61110	break;
60499	61111	}
60500		- case 18446744073709548036LLU: // 99999999HD'''''''''''''''
	61112	+ case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
60501	61113	{
60502		- state.addr = 18446744073709548037LLU; // 99999999HE'''''''''''''''
	61114	+ state.addr = 18446744073709547997LLU; // 99999999Gb'''''''''''''''
60503	61115	break;
60504	61116	}
60505		- case 18446744073709548037LLU: // 99999999HE'''''''''''''''
	61117	+ case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
60506	61118	{
60507	61119	{
60508	61120	fprintf(stderr, "%s\n", "assignment to list not implemeted yet");

		@@ -60510,10 +61122,10 @@
60510	61122	}
60511	61123	heap.availilable_size_for_dynamic_objects += 0LLU;
60512	61124	heap.availilable_size_for_dynamic_objects += 0LLU;
60513		- state.addr = 18446744073709548035LLU; // 99999999HC'''''''''''''''
	61125	+ state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
60514	61126	break;
60515	61127	}
60516		- case 18446744073709548038LLU: // 99999999HF'''''''''''''''
	61128	+ case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
60517	61129	{
60518	61130	{
60519	61131	uint64_t arg = 0LLU;

		@@ -60525,7 +61137,7 @@
60525	61137	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60526	61138	}
60527	61139	// ACCUMULATE ARGUMENTS - END
60528		- uint64_t return_to = 18446744073709548033LLU;
	61140	+ uint64_t return_to = 18446744073709547993LLU;
60529	61141	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60530	61142	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60531	61143	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60534,12 +61146,12 @@
60534	61146	state.addr = 839519719621918720LLU; // skipws____
60535	61147	break;
60536	61148	}
60537		- case 18446744073709548033LLU: // 99999999HA'''''''''''''''
	61149	+ case 18446744073709547993LLU: // 99999999GY'''''''''''''''
60538	61150	{
60539		- state.addr = 18446744073709548034LLU; // 99999999HB'''''''''''''''
	61151	+ state.addr = 18446744073709547994LLU; // 99999999GZ'''''''''''''''
60540	61152	break;
60541	61153	}
60542		- case 18446744073709548034LLU: // 99999999HB'''''''''''''''
	61154	+ case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
60543	61155	{
60544	61156	/srcid_____/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 8LLU)));
60545	61157	{

		@@ -60564,7 +61176,7 @@
60564	61176	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60565	61177	}
60566	61178	// ACCUMULATE ARGUMENTS - END
60567		- uint64_t return_to = 18446744073709548031LLU;
	61179	+ uint64_t return_to = 18446744073709547991LLU;
60568	61180	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
60569	61181	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60570	61182	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60573,17 +61185,17 @@
60573	61185	state.addr = 728666047794575267LLU; // matchoptch
60574	61186	break;
60575	61187	}
60576		- case 18446744073709548031LLU: // 99999999G9'''''''''''''''
	61188	+ case 18446744073709547991LLU: // 99999999GW'''''''''''''''
60577	61189	{
60578		- state.addr = 18446744073709548032LLU; // 99999999H_'''''''''''''''
	61190	+ state.addr = 18446744073709547992LLU; // 99999999GX'''''''''''''''
60579	61191	break;
60580	61192	}
60581		- case 18446744073709548032LLU: // 99999999H_'''''''''''''''
	61193	+ case 18446744073709547992LLU: // 99999999GX'''''''''''''''
60582	61194	{
60583		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709548030LLU : 18446744073709548029LLU;
	61195	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547990LLU : 18446744073709547989LLU;
60584	61196	break;
60585	61197	}
60586		- case 18446744073709548030LLU: // 99999999G8'''''''''''''''
	61198	+ case 18446744073709547990LLU: // 99999999GV'''''''''''''''
60587	61199	{
60588	61200	// ACCUMULATE ARGUMENTS - BEGIN
60589	61201	{

		@@ -60591,7 +61203,7 @@
60591	61203	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60592	61204	}
60593	61205	// ACCUMULATE ARGUMENTS - END
60594		- uint64_t return_to = 18446744073709548027LLU;
	61206	+ uint64_t return_to = 18446744073709547987LLU;
60595	61207	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60596	61208	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60597	61209	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60600,12 +61212,12 @@
60600	61212	state.addr = 819847183515949359LLU; // reportinit
60601	61213	break;
60602	61214	}
60603		- case 18446744073709548027LLU: // 99999999G5'''''''''''''''
	61215	+ case 18446744073709547987LLU: // 99999999GS'''''''''''''''
60604	61216	{
60605		- state.addr = 18446744073709548028LLU; // 99999999G6'''''''''''''''
	61217	+ state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
60606	61218	break;
60607	61219	}
60608		- case 18446744073709548028LLU: // 99999999G6'''''''''''''''
	61220	+ case 18446744073709547988LLU: // 99999999GT'''''''''''''''
60609	61221	{
60610	61222	printid(stderr, /srcid_____/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU));
60611	61223	fprintf(stderr, "%s", " / ");

		@@ -60617,10 +61229,10 @@
60617	61229	}
60618	61230	heap.availilable_size_for_dynamic_objects += 0LLU;
60619	61231	heap.availilable_size_for_dynamic_objects += 0LLU;
60620		- state.addr = 18446744073709548026LLU; // 99999999G4'''''''''''''''
	61232	+ state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
60621	61233	break;
60622	61234	}
60623		- case 18446744073709548029LLU: // 99999999G7'''''''''''''''
	61235	+ case 18446744073709547989LLU: // 99999999GU'''''''''''''''
60624	61236	{
60625	61237	// ACCUMULATE ARGUMENTS - BEGIN
60626	61238	{

		@@ -60632,7 +61244,7 @@
60632	61244	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60633	61245	}
60634	61246	// ACCUMULATE ARGUMENTS - END
60635		- uint64_t return_to = 18446744073709548024LLU;
	61247	+ uint64_t return_to = 18446744073709547984LLU;
60636	61248	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
60637	61249	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60638	61250	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60641,12 +61253,12 @@
60641	61253	state.addr = 517555565476695680LLU; // assertu64_
60642	61254	break;
60643	61255	}
60644		- case 18446744073709548024LLU: // 99999999G2'''''''''''''''
	61256	+ case 18446744073709547984LLU: // 99999999GP'''''''''''''''
60645	61257	{
60646		- state.addr = 18446744073709548025LLU; // 99999999G3'''''''''''''''
	61258	+ state.addr = 18446744073709547985LLU; // 99999999GQ'''''''''''''''
60647	61259	break;
60648	61260	}
60649		- case 18446744073709548025LLU: // 99999999G3'''''''''''''''
	61261	+ case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
60650	61262	{
60651	61263	// ACCUMULATE ARGUMENTS - BEGIN
60652	61264	{

		@@ -60670,7 +61282,7 @@
60670	61282	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60671	61283	}
60672	61284	// ACCUMULATE ARGUMENTS - END
60673		- uint64_t return_to = 18446744073709548022LLU;
	61285	+ uint64_t return_to = 18446744073709547982LLU;
60674	61286	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
60675	61287	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60676	61288	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60679,12 +61291,12 @@
60679	61291	state.addr = 587881357514113024LLU; // emitpar___
60680	61292	break;
60681	61293	}
60682		- case 18446744073709548022LLU: // 99999999G0'''''''''''''''
	61294	+ case 18446744073709547982LLU: // 99999999GN'''''''''''''''
60683	61295	{
60684		- state.addr = 18446744073709548023LLU; // 99999999G1'''''''''''''''
	61296	+ state.addr = 18446744073709547983LLU; // 99999999GO'''''''''''''''
60685	61297	break;
60686	61298	}
60687		- case 18446744073709548023LLU: // 99999999G1'''''''''''''''
	61299	+ case 18446744073709547983LLU: // 99999999GO'''''''''''''''
60688	61300	{
60689	61301	fprintf(stdout, "%s", " = ");
60690	61302	*LOCAL_ACCESS(heap.data, 22LLU, 14LLU) = 0LLU;

		@@ -60699,7 +61311,7 @@
60699	61311	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60700	61312	}
60701	61313	// ACCUMULATE ARGUMENTS - END
60702		- uint64_t return_to = 18446744073709548020LLU;
	61314	+ uint64_t return_to = 18446744073709547980LLU;
60703	61315	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60704	61316	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60705	61317	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60708,12 +61320,12 @@
60708	61320	state.addr = 861504796319285248LLU; // typeu64___
60709	61321	break;
60710	61322	}
60711		- case 18446744073709548020LLU: // 99999999Gy'''''''''''''''
	61323	+ case 18446744073709547980LLU: // 99999999GL'''''''''''''''
60712	61324	{
60713		- state.addr = 18446744073709548021LLU; // 99999999Gz'''''''''''''''
	61325	+ state.addr = 18446744073709547981LLU; // 99999999GM'''''''''''''''
60714	61326	break;
60715	61327	}
60716		- case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
	61328	+ case 18446744073709547981LLU: // 99999999GM'''''''''''''''
60717	61329	{
60718	61330	{
60719	61331	uint64_t arg = 0LLU;

		@@ -60787,7 +61399,7 @@
60787	61399	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60788	61400	}
60789	61401	// ACCUMULATE ARGUMENTS - END
60790		- uint64_t return_to = 18446744073709548018LLU;
	61402	+ uint64_t return_to = 18446744073709547978LLU;
60791	61403	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
60792	61404	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60793	61405	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60796,12 +61408,12 @@
60796	61408	state.addr = 787472342492567585LLU; // procvarref
60797	61409	break;
60798	61410	}
60799		- case 18446744073709548018LLU: // 99999999Gw'''''''''''''''
	61411	+ case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
60800	61412	{
60801		- state.addr = 18446744073709548019LLU; // 99999999Gx'''''''''''''''
	61413	+ state.addr = 18446744073709547979LLU; // 99999999GK'''''''''''''''
60802	61414	break;
60803	61415	}
60804		- case 18446744073709548019LLU: // 99999999Gx'''''''''''''''
	61416	+ case 18446744073709547979LLU: // 99999999GK'''''''''''''''
60805	61417	{
60806	61418	// ACCUMULATE ARGUMENTS - BEGIN
60807	61419	{

		@@ -60821,7 +61433,7 @@
60821	61433	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60822	61434	}
60823	61435	// ACCUMULATE ARGUMENTS - END
60824		- uint64_t return_to = 18446744073709548016LLU;
	61436	+ uint64_t return_to = 18446744073709547976LLU;
60825	61437	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
60826	61438	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60827	61439	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60830,12 +61442,12 @@
60830	61442	state.addr = 861504774606571689LLU; // typeassign
60831	61443	break;
60832	61444	}
60833		- case 18446744073709548016LLU: // 99999999Gu'''''''''''''''
	61445	+ case 18446744073709547976LLU: // 99999999GH'''''''''''''''
60834	61446	{
60835		- state.addr = 18446744073709548017LLU; // 99999999Gv'''''''''''''''
	61447	+ state.addr = 18446744073709547977LLU; // 99999999GI'''''''''''''''
60836	61448	break;
60837	61449	}
60838		- case 18446744073709548017LLU: // 99999999Gv'''''''''''''''
	61450	+ case 18446744073709547977LLU: // 99999999GI'''''''''''''''
60839	61451	{
60840	61452	// variable u64 parameter_ goes out of scope
60841	61453	// emitted destructur for type u64

		@@ -60851,7 +61463,7 @@
60851	61463	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60852	61464	}
60853	61465	// ACCUMULATE ARGUMENTS - END
60854		- uint64_t return_to = 18446744073709548015LLU;
	61466	+ uint64_t return_to = 18446744073709547975LLU;
60855	61467	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60856	61468	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60857	61469	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60860,13 +61472,13 @@
60860	61472	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
60861	61473	break;
60862	61474	}
60863		- case 18446744073709548015LLU: // 99999999Gt'''''''''''''''
	61475	+ case 18446744073709547975LLU: // 99999999GG'''''''''''''''
60864	61476	{
60865	61477	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typesrc___ at 23
60866		- state.addr = 18446744073709548026LLU; // 99999999G4'''''''''''''''
	61478	+ state.addr = 18446744073709547986LLU; // 99999999GR'''''''''''''''
60867	61479	break;
60868	61480	}
60869		- case 18446744073709548026LLU: // 99999999G4'''''''''''''''
	61481	+ case 18446744073709547986LLU: // 99999999GR'''''''''''''''
60870	61482	{
60871	61483	// variable u64 called____ goes out of scope
60872	61484	// emitted destructur for type u64

		@@ -60877,21 +61489,21 @@
60877	61489	// variable u64 srcid_____ goes out of scope
60878	61490	// emitted destructur for type u64
60879	61491	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference srcid_____ at 20
60880		- state.addr = 18446744073709548035LLU; // 99999999HC'''''''''''''''
	61492	+ state.addr = 18446744073709547995LLU; // 99999999G$'''''''''''''''
60881	61493	break;
60882	61494	}
60883		- case 18446744073709548035LLU: // 99999999HC'''''''''''''''
	61495	+ case 18446744073709547995LLU: // 99999999G$'''''''''''''''
60884	61496	{
60885	61497	fprintf(stdout, "%s", ";\n");
60886		- state.addr = 18446744073709548040LLU; // 99999999HH'''''''''''''''
	61498	+ state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
60887	61499	break;
60888	61500	}
60889		- case 18446744073709548040LLU: // 99999999HH'''''''''''''''
	61501	+ case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
60890	61502	{
60891		- state.addr = 18446744073709548061LLU; // 99999999Hb'''''''''''''''
	61503	+ state.addr = 18446744073709548021LLU; // 99999999Gz'''''''''''''''
60892	61504	break;
60893	61505	}
60894		- case 18446744073709548061LLU: // 99999999Hb'''''''''''''''
	61506	+ case 18446744073709548021LLU: // 99999999Gz'''''''''''''''
60895	61507	{
60896	61508	// variable u64 match_____ goes out of scope
60897	61509	// emitted destructur for type u64

		@@ -60916,7 +61528,7 @@
60916	61528	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60917	61529	}
60918	61530	// ACCUMULATE ARGUMENTS - END
60919		- uint64_t return_to = 18446744073709548014LLU;
	61531	+ uint64_t return_to = 18446744073709547974LLU;
60920	61532	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
60921	61533	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
60922	61534	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -60925,7 +61537,7 @@
60925	61537	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
60926	61538	break;
60927	61539	}
60928		- case 18446744073709548014LLU: // 99999999Gs'''''''''''''''
	61540	+ case 18446744073709547974LLU: // 99999999GF'''''''''''''''
60929	61541	{
60930	61542	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference TYPEDST___ at 14
60931	61543	// parameter-reference u64 remainheap goes out of scope

		@@ -60994,7 +61606,7 @@
60994	61606	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
60995	61607	}
60996	61608	// ACCUMULATE ARGUMENTS - END
60997		- uint64_t return_to = 18446744073709548012LLU;
	61609	+ uint64_t return_to = 18446744073709547972LLU;
60998	61610	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0));
60999	61611	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61000	61612	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61003,12 +61615,12 @@
61003	61615	state.addr = 533581901922699840LLU; // blockopen_
61004	61616	break;
61005	61617	}
61006		- case 18446744073709548012LLU: // 99999999Gq'''''''''''''''
	61618	+ case 18446744073709547972LLU: // 99999999GD'''''''''''''''
61007	61619	{
61008		- state.addr = 18446744073709548013LLU; // 99999999Gr'''''''''''''''
	61620	+ state.addr = 18446744073709547973LLU; // 99999999GE'''''''''''''''
61009	61621	break;
61010	61622	}
61011		- case 18446744073709548013LLU: // 99999999Gr'''''''''''''''
	61623	+ case 18446744073709547973LLU: // 99999999GE'''''''''''''''
61012	61624	{
61013	61625	{
61014	61626	uint64_t arg = 0LLU;

		@@ -61020,7 +61632,7 @@
61020	61632	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61021	61633	}
61022	61634	// ACCUMULATE ARGUMENTS - END
61023		- uint64_t return_to = 18446744073709548010LLU;
	61635	+ uint64_t return_to = 18446744073709547970LLU;
61024	61636	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61025	61637	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61026	61638	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61029,12 +61641,12 @@
61029	61641	state.addr = 839519719621918720LLU; // skipws____
61030	61642	break;
61031	61643	}
61032		- case 18446744073709548010LLU: // 99999999Go'''''''''''''''
	61644	+ case 18446744073709547970LLU: // 99999999GB'''''''''''''''
61033	61645	{
61034		- state.addr = 18446744073709548011LLU; // 99999999Gp'''''''''''''''
	61646	+ state.addr = 18446744073709547971LLU; // 99999999GC'''''''''''''''
61035	61647	break;
61036	61648	}
61037		- case 18446744073709548011LLU: // 99999999Gp'''''''''''''''
	61649	+ case 18446744073709547971LLU: // 99999999GC'''''''''''''''
61038	61650	{
61039	61651	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)), stdin);
61040	61652	if('(' != (char)getchar())

		@@ -61042,15 +61654,15 @@
61042	61654	fprintf(stderr, "match failed at char %c\n", (char)40LLU);
61043	61655	exit(-1);
61044	61656	}
61045		- state.addr = 18446744073709548009LLU; // 99999999Gn'''''''''''''''
	61657	+ state.addr = 18446744073709547969LLU; // 99999999GA'''''''''''''''
61046	61658	break;
61047	61659	}
61048		- case 18446744073709548009LLU: // 99999999Gn'''''''''''''''
	61660	+ case 18446744073709547969LLU: // 99999999GA'''''''''''''''
61049	61661	{
61050	61662	access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
61051	61663	if(!access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) \|\| access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255)
61052	61664	{
61053		- state.addr = 18446744073709548008LLU; // 99999999Gm'''''''''''''''
	61665	+ state.addr = 18446744073709547968LLU; // 99999999G_'''''''''''''''
61054	61666	break;
61055	61667	}
61056	61668	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -61059,7 +61671,7 @@
61059	61671	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61060	61672	}
61061	61673	// ACCUMULATE ARGUMENTS - END
61062		- uint64_t return_to = 18446744073709548006LLU;
	61674	+ uint64_t return_to = 18446744073709547966LLU;
61063	61675	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61064	61676	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61065	61677	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61068,12 +61680,12 @@
61068	61680	state.addr = 839519719621918720LLU; // skipws____
61069	61681	break;
61070	61682	}
61071		- case 18446744073709548006LLU: // 99999999Gk'''''''''''''''
	61683	+ case 18446744073709547966LLU: // 99999999F8'''''''''''''''
61072	61684	{
61073		- state.addr = 18446744073709548007LLU; // 99999999Gl'''''''''''''''
	61685	+ state.addr = 18446744073709547967LLU; // 99999999F9'''''''''''''''
61074	61686	break;
61075	61687	}
61076		- case 18446744073709548007LLU: // 99999999Gl'''''''''''''''
	61688	+ case 18446744073709547967LLU: // 99999999F9'''''''''''''''
61077	61689	{
61078	61690	{
61079	61691	uint64_t arg = 44LLU;

		@@ -61088,10 +61700,10 @@
61088	61700	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
61089	61701	}
61090	61702	/result____/LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /terminator/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) != /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 21LLU, 11LLU));
61091		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709548005LLU : 18446744073709548004LLU;
	61703	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547965LLU : 18446744073709547964LLU;
61092	61704	break;
61093	61705	}
61094		- case 18446744073709548005LLU: // 99999999Gj'''''''''''''''
	61706	+ case 18446744073709547965LLU: // 99999999F7'''''''''''''''
61095	61707	{
61096	61708	{
61097	61709	uint64_t arg = 0LLU;

		@@ -61103,7 +61715,7 @@
61103	61715	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61104	61716	}
61105	61717	// ACCUMULATE ARGUMENTS - END
61106		- uint64_t return_to = 18446744073709548002LLU;
	61718	+ uint64_t return_to = 18446744073709547962LLU;
61107	61719	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61108	61720	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61109	61721	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61112,12 +61724,12 @@
61112	61724	state.addr = 839519719621918720LLU; // skipws____
61113	61725	break;
61114	61726	}
61115		- case 18446744073709548002LLU: // 99999999Gg'''''''''''''''
	61727	+ case 18446744073709547962LLU: // 99999999F4'''''''''''''''
61116	61728	{
61117		- state.addr = 18446744073709548003LLU; // 99999999Gh'''''''''''''''
	61729	+ state.addr = 18446744073709547963LLU; // 99999999F5'''''''''''''''
61118	61730	break;
61119	61731	}
61120		- case 18446744073709548003LLU: // 99999999Gh'''''''''''''''
	61732	+ case 18446744073709547963LLU: // 99999999F5'''''''''''''''
61121	61733	{
61122	61734	/resultid__/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)));
61123	61735	{

		@@ -61130,7 +61742,7 @@
61130	61742	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61131	61743	}
61132	61744	// ACCUMULATE ARGUMENTS - END
61133		- uint64_t return_to = 18446744073709547999LLU;
	61745	+ uint64_t return_to = 18446744073709547959LLU;
61134	61746	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61135	61747	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61136	61748	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61139,12 +61751,12 @@
61139	61751	state.addr = 861504796319285248LLU; // typeu64___
61140	61752	break;
61141	61753	}
61142		- case 18446744073709547999LLU: // 99999999Gd'''''''''''''''
	61754	+ case 18446744073709547959LLU: // 99999999F1'''''''''''''''
61143	61755	{
61144		- state.addr = 18446744073709548000LLU; // 99999999Ge'''''''''''''''
	61756	+ state.addr = 18446744073709547960LLU; // 99999999F2'''''''''''''''
61145	61757	break;
61146	61758	}
61147		- case 18446744073709548000LLU: // 99999999Ge'''''''''''''''
	61759	+ case 18446744073709547960LLU: // 99999999F2'''''''''''''''
61148	61760	{
61149	61761	{
61150	61762	uint64_t arg = 0LLU;

		@@ -61224,7 +61836,7 @@
61224	61836	LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61225	61837	}
61226	61838	// ACCUMULATE ARGUMENTS - END
61227		- uint64_t return_to = 18446744073709547997LLU;
	61839	+ uint64_t return_to = 18446744073709547957LLU;
61228	61840	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0));
61229	61841	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61230	61842	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61233,27 +61845,27 @@
61233	61845	state.addr = 604790753280317473LLU; // findvarref
61234	61846	break;
61235	61847	}
61236		- case 18446744073709547997LLU: // 99999999Gb'''''''''''''''
	61848	+ case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
61237	61849	{
61238		- state.addr = 18446744073709547998LLU; // 99999999Gc'''''''''''''''
	61850	+ state.addr = 18446744073709547958LLU; // 99999999F0'''''''''''''''
61239	61851	break;
61240	61852	}
61241		- case 18446744073709547998LLU: // 99999999Gc'''''''''''''''
	61853	+ case 18446744073709547958LLU: // 99999999F0'''''''''''''''
61242	61854	{
61243		- state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547996LLU : 18446744073709547995LLU;
	61855	+ state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 27LLU) ? 18446744073709547956LLU : 18446744073709547955LLU;
61244	61856	break;
61245	61857	}
61246		- case 18446744073709547996LLU: // 99999999Ga'''''''''''''''
	61858	+ case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
61247	61859	{
61248		- state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709547994LLU : 18446744073709547993LLU;
	61860	+ state.addr = *LOCAL_ACCESS(heap.data, 30LLU, 25LLU) ? 18446744073709547954LLU : 18446744073709547953LLU;
61249	61861	break;
61250	61862	}
61251		- case 18446744073709547994LLU: // 99999999GZ'''''''''''''''
	61863	+ case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
61252	61864	{
61253		- state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 30LLU, 22LLU)].elem0 ? 18446744073709547992LLU : 18446744073709547991LLU;
	61865	+ state.addr = 1LLU == heap.data[*LOCAL_ACCESS(heap.data, 30LLU, 22LLU)].elem0 ? 18446744073709547952LLU : 18446744073709547951LLU;
61254	61866	break;
61255	61867	}
61256		- case 18446744073709547992LLU: // 99999999GX'''''''''''''''
	61868	+ case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
61257	61869	{
61258	61870	{
61259	61871	uint64_t arg = tree_elem_addr(heap.data, 1LLU, tree_elem_addr(heap.data, 2/addr-content-pair/, LOCAL_ACCESS_ADDR(heap.data, 30LLU, 22LLU), 1/content/), 0LLU);

		@@ -61277,7 +61889,7 @@
61277	61889	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61278	61890	}
61279	61891	// ACCUMULATE ARGUMENTS - END
61280		- uint64_t return_to = 18446744073709547989LLU;
	61892	+ uint64_t return_to = 18446744073709547949LLU;
61281	61893	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
61282	61894	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61283	61895	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61286,12 +61898,12 @@
61286	61898	state.addr = 861504788261634048LLU; // typename__
61287	61899	break;
61288	61900	}
61289		- case 18446744073709547989LLU: // 99999999GU'''''''''''''''
	61901	+ case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
61290	61902	{
61291		- state.addr = 18446744073709547990LLU; // 99999999GV'''''''''''''''
	61903	+ state.addr = 18446744073709547950LLU; // 99999999Fs'''''''''''''''
61292	61904	break;
61293	61905	}
61294		- case 18446744073709547990LLU: // 99999999GV'''''''''''''''
	61906	+ case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
61295	61907	{
61296	61908	// ACCUMULATE ARGUMENTS - BEGIN
61297	61909	{

		@@ -61331,7 +61943,7 @@
61331	61943	LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61332	61944	}
61333	61945	// ACCUMULATE ARGUMENTS - END
61334		- uint64_t return_to = 18446744073709547987LLU;
	61946	+ uint64_t return_to = 18446744073709547947LLU;
61335	61947	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0));
61336	61948	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61337	61949	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61340,12 +61952,12 @@
61340	61952	state.addr = 587881344696777536LLU; // emitdestr_
61341	61953	break;
61342	61954	}
61343		- case 18446744073709547987LLU: // 99999999GS'''''''''''''''
	61955	+ case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
61344	61956	{
61345		- state.addr = 18446744073709547988LLU; // 99999999GT'''''''''''''''
	61957	+ state.addr = 18446744073709547948LLU; // 99999999Fq'''''''''''''''
61346	61958	break;
61347	61959	}
61348		- case 18446744073709547988LLU: // 99999999GT'''''''''''''''
	61960	+ case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
61349	61961	{
61350	61962	// variable type______ type______ goes out of scope
61351	61963	// emitted destructur for type type______

		@@ -61355,7 +61967,7 @@
61355	61967	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61356	61968	}
61357	61969	// ACCUMULATE ARGUMENTS - END
61358		- uint64_t return_to = 18446744073709547986LLU;
	61970	+ uint64_t return_to = 18446744073709547946LLU;
61359	61971	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61360	61972	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61361	61973	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61364,7 +61976,7 @@
61364	61976	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
61365	61977	break;
61366	61978	}
61367		- case 18446744073709547986LLU: // 99999999GR'''''''''''''''
	61979	+ case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
61368	61980	{
61369	61981	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 33
61370	61982	// variable u64 name______ goes out of scope

		@@ -61374,22 +61986,22 @@
61374	61986	(void)LOCAL_POP_MOVE(&heap, 31LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference name______ at 31
61375	61987	heap.availilable_size_for_dynamic_objects += 0LLU;
61376	61988	heap.availilable_size_for_dynamic_objects += 0LLU;
61377		- state.addr = 18446744073709547985LLU; // 99999999GQ'''''''''''''''
	61989	+ state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
61378	61990	break;
61379	61991	}
61380		- case 18446744073709547991LLU: // 99999999GW'''''''''''''''
	61992	+ case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
61381	61993	{
61382		- state.addr = 18446744073709547985LLU; // 99999999GQ'''''''''''''''
	61994	+ state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
61383	61995	break;
61384	61996	}
61385		- case 18446744073709547985LLU: // 99999999GQ'''''''''''''''
	61997	+ case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
61386	61998	{
61387	61999	heap.availilable_size_for_dynamic_objects += 0LLU;
61388	62000	heap.availilable_size_for_dynamic_objects += 0LLU;
61389		- state.addr = 18446744073709547984LLU; // 99999999GP'''''''''''''''
	62001	+ state.addr = 18446744073709547944LLU; // 99999999Fm'''''''''''''''
61390	62002	break;
61391	62003	}
61392		- case 18446744073709547993LLU: // 99999999GY'''''''''''''''
	62004	+ case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
61393	62005	{
61394	62006	fprintf(stderr, "%s", "cannot assign to constant ");
61395	62007	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -61398,7 +62010,7 @@
61398	62010	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61399	62011	}
61400	62012	// ACCUMULATE ARGUMENTS - END
61401		- uint64_t return_to = 18446744073709547982LLU;
	62013	+ uint64_t return_to = 18446744073709547942LLU;
61402	62014	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61403	62015	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61404	62016	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61407,12 +62019,12 @@
61407	62019	state.addr = 819847183518878432LLU; // reporttype
61408	62020	break;
61409	62021	}
61410		- case 18446744073709547982LLU: // 99999999GN'''''''''''''''
	62022	+ case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
61411	62023	{
61412		- state.addr = 18446744073709547983LLU; // 99999999GO'''''''''''''''
	62024	+ state.addr = 18446744073709547943LLU; // 99999999Fl'''''''''''''''
61413	62025	break;
61414	62026	}
61415		- case 18446744073709547983LLU: // 99999999GO'''''''''''''''
	62027	+ case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
61416	62028	{
61417	62029	fprintf(stderr, "%s", " ");
61418	62030	printid(stderr, /resultid__/*LOCAL_ACCESS(heap.data, 30LLU, 21LLU));

		@@ -61420,17 +62032,17 @@
61420	62032	fprintf(stderr, "%s\n", "");
61421	62033	exit(-1);
61422	62034	}
61423		- state.addr = 18446744073709547984LLU; // 99999999GP'''''''''''''''
	62035	+ state.addr = 18446744073709547944LLU; // 99999999Fm'''''''''''''''
61424	62036	break;
61425	62037	}
61426		- case 18446744073709547984LLU: // 99999999GP'''''''''''''''
	62038	+ case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
61427	62039	{
61428	62040	heap.availilable_size_for_dynamic_objects += 0LLU;
61429	62041	heap.availilable_size_for_dynamic_objects += 0LLU;
61430		- state.addr = 18446744073709547981LLU; // 99999999GM'''''''''''''''
	62042	+ state.addr = 18446744073709547941LLU; // 99999999Fj'''''''''''''''
61431	62043	break;
61432	62044	}
61433		- case 18446744073709547995LLU: // 99999999G$'''''''''''''''
	62045	+ case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
61434	62046	{
61435	62047	// ACCUMULATE ARGUMENTS - BEGIN
61436	62048	{

		@@ -61450,7 +62062,7 @@
61450	62062	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61451	62063	}
61452	62064	// ACCUMULATE ARGUMENTS - END
61453		- uint64_t return_to = 18446744073709547979LLU;
	62065	+ uint64_t return_to = 18446744073709547939LLU;
61454	62066	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
61455	62067	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61456	62068	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61459,17 +62071,17 @@
61459	62071	state.addr = 660220432971388961LLU; // initvarref
61460	62072	break;
61461	62073	}
61462		- case 18446744073709547979LLU: // 99999999GK'''''''''''''''
	62074	+ case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
61463	62075	{
61464		- state.addr = 18446744073709547980LLU; // 99999999GL'''''''''''''''
	62076	+ state.addr = 18446744073709547940LLU; // 99999999Fi'''''''''''''''
61465	62077	break;
61466	62078	}
61467		- case 18446744073709547980LLU: // 99999999GL'''''''''''''''
	62079	+ case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
61468	62080	{
61469		- state.addr = 18446744073709547981LLU; // 99999999GM'''''''''''''''
	62081	+ state.addr = 18446744073709547941LLU; // 99999999Fj'''''''''''''''
61470	62082	break;
61471	62083	}
61472		- case 18446744073709547981LLU: // 99999999GM'''''''''''''''
	62084	+ case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
61473	62085	{
61474	62086	{
61475	62087	uint64_t arg = 0LLU;

		@@ -61502,7 +62114,7 @@
61502	62114	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61503	62115	}
61504	62116	// ACCUMULATE ARGUMENTS - END
61505		- uint64_t return_to = 18446744073709547977LLU;
	62117	+ uint64_t return_to = 18446744073709547937LLU;
61506	62118	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
61507	62119	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61508	62120	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61511,12 +62123,12 @@
61511	62123	state.addr = 734295421765213120LLU; // mutassert_
61512	62124	break;
61513	62125	}
61514		- case 18446744073709547977LLU: // 99999999GI'''''''''''''''
	62126	+ case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
61515	62127	{
61516		- state.addr = 18446744073709547978LLU; // 99999999GJ'''''''''''''''
	62128	+ state.addr = 18446744073709547938LLU; // 99999999Fg'''''''''''''''
61517	62129	break;
61518	62130	}
61519		- case 18446744073709547978LLU: // 99999999GJ'''''''''''''''
	62131	+ case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
61520	62132	{
61521	62133	{
61522	62134	uint64_t arg = /resultid__/*LOCAL_ACCESS(heap.data, 32LLU, 21LLU);

		@@ -61545,7 +62157,7 @@
61545	62157	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61546	62158	}
61547	62159	// ACCUMULATE ARGUMENTS - END
61548		- uint64_t return_to = 18446744073709547970LLU;
	62160	+ uint64_t return_to = 18446744073709547930LLU;
61549	62161	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61550	62162	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61551	62163	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61554,12 +62166,12 @@
61554	62166	state.addr = 890786773858934784LLU; // varblock__
61555	62167	break;
61556	62168	}
61557		- case 18446744073709547970LLU: // 99999999GB'''''''''''''''
	62169	+ case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
61558	62170	{
61559		- state.addr = 18446744073709547971LLU; // 99999999GC'''''''''''''''
	62171	+ state.addr = 18446744073709547931LLU; // 99999999F$'''''''''''''''
61560	62172	break;
61561	62173	}
61562		- case 18446744073709547971LLU: // 99999999GC'''''''''''''''
	62174	+ case 18446744073709547931LLU: // 99999999F$'''''''''''''''
61563	62175	{
61564	62176	{
61565	62177	uint64_t exchange = LOCAL_POP_MOVE(&heap, 36LLU, &(heap.data[0].elem1)/address of current closure/) /* RELEASE temporary reference at 36*/;

		@@ -61575,7 +62187,7 @@
61575	62187	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61576	62188	}
61577	62189	// ACCUMULATE ARGUMENTS - END
61578		- uint64_t return_to = 18446744073709547972LLU;
	62190	+ uint64_t return_to = 18446744073709547932LLU;
61579	62191	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0));
61580	62192	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61581	62193	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61584,17 +62196,17 @@
61584	62196	state.addr = 890786982252724224LLU; // varentry__
61585	62197	break;
61586	62198	}
61587		- case 18446744073709547972LLU: // 99999999GD'''''''''''''''
	62199	+ case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
61588	62200	{
61589		- state.addr = 18446744073709547973LLU; // 99999999GE'''''''''''''''
	62201	+ state.addr = 18446744073709547933LLU; // 99999999Fb'''''''''''''''
61590	62202	break;
61591	62203	}
61592		- case 18446744073709547973LLU: // 99999999GE'''''''''''''''
	62204	+ case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
61593	62205	{
61594		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547975LLU : 18446744073709547974LLU;
	62206	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 34LLU, 33LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 34LLU, 9LLU)), 15) ? 18446744073709547935LLU : 18446744073709547934LLU;
61595	62207	break;
61596	62208	}
61597		- case 18446744073709547975LLU: // 99999999GG'''''''''''''''
	62209	+ case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
61598	62210	{
61599	62211	{
61600	62212	uint64_t arg = *LOCAL_ACCESS(heap.data, 34LLU, 33LLU);

		@@ -61606,7 +62218,7 @@
61606	62218	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61607	62219	}
61608	62220	// ACCUMULATE ARGUMENTS - END
61609		- uint64_t return_to = 18446744073709547968LLU;
	62221	+ uint64_t return_to = 18446744073709547928LLU;
61610	62222	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61611	62223	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61612	62224	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61615,12 +62227,12 @@
61615	62227	state.addr = 819847183515949359LLU; // reportinit
61616	62228	break;
61617	62229	}
61618		- case 18446744073709547968LLU: // 99999999G_'''''''''''''''
	62230	+ case 18446744073709547928LLU: // 99999999FX'''''''''''''''
61619	62231	{
61620		- state.addr = 18446744073709547969LLU; // 99999999GA'''''''''''''''
	62232	+ state.addr = 18446744073709547929LLU; // 99999999FY'''''''''''''''
61621	62233	break;
61622	62234	}
61623		- case 18446744073709547969LLU: // 99999999GA'''''''''''''''
	62235	+ case 18446744073709547929LLU: // 99999999FY'''''''''''''''
61624	62236	{
61625	62237	fprintf(stderr, "%s", "pushing block ");
61626	62238	printid(stderr, /resultid__/*LOCAL_ACCESS(heap.data, 35LLU, 21LLU));

		@@ -61637,7 +62249,7 @@
61637	62249	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61638	62250	}
61639	62251	// ACCUMULATE ARGUMENTS - END
61640		- uint64_t return_to = 18446744073709547967LLU;
	62252	+ uint64_t return_to = 18446744073709547927LLU;
61641	62253	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61642	62254	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61643	62255	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61646,20 +62258,20 @@
61646	62258	state.addr = 18446744073709551045LLU; // 999999991E'''''''''''''''
61647	62259	break;
61648	62260	}
61649		- case 18446744073709547967LLU: // 99999999F9'''''''''''''''
	62261	+ case 18446744073709547927LLU: // 99999999FW'''''''''''''''
61650	62262	{
61651	62263	(void)LOCAL_POP_MOVE(&heap, 35LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference block_____ at 35
61652	62264	heap.availilable_size_for_dynamic_objects += 0LLU;
61653	62265	heap.availilable_size_for_dynamic_objects += 0LLU;
61654		- state.addr = 18446744073709547966LLU; // 99999999F8'''''''''''''''
	62266	+ state.addr = 18446744073709547926LLU; // 99999999FV'''''''''''''''
61655	62267	break;
61656	62268	}
61657		- case 18446744073709547974LLU: // 99999999GF'''''''''''''''
	62269	+ case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
61658	62270	{
61659		- state.addr = 18446744073709547966LLU; // 99999999F8'''''''''''''''
	62271	+ state.addr = 18446744073709547926LLU; // 99999999FV'''''''''''''''
61660	62272	break;
61661	62273	}
61662		- case 18446744073709547966LLU: // 99999999F8'''''''''''''''
	62274	+ case 18446744073709547926LLU: // 99999999FV'''''''''''''''
61663	62275	{
61664	62276	// variable varentry__ __________ goes out of scope
61665	62277	// (uninitialized -> no destructor-call)

		@@ -61667,10 +62279,10 @@
61667	62279	// variable u64 id2_______ goes out of scope
61668	62280	// (uninitialized -> no destructor-call)
61669	62281	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id2_______ at 33
61670		- state.addr = 18446744073709547976LLU; // 99999999GH'''''''''''''''
	62282	+ state.addr = 18446744073709547936LLU; // 99999999Fe'''''''''''''''
61671	62283	break;
61672	62284	}
61673		- case 18446744073709547976LLU: // 99999999GH'''''''''''''''
	62285	+ case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
61674	62286	{/resdest___/
61675	62287	{
61676	62288	uint64_t arg = 0;

		@@ -61694,7 +62306,7 @@
61694	62306	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61695	62307	}
61696	62308	// ACCUMULATE ARGUMENTS - END
61697		- uint64_t return_to = 18446744073709547961LLU;
	62309	+ uint64_t return_to = 18446744073709547921LLU;
61698	62310	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
61699	62311	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61700	62312	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61703,17 +62315,17 @@
61703	62315	state.addr = 819859607768530944LLU; // resdest___
61704	62316	break;
61705	62317	}
61706		- case 18446744073709547961LLU: // 99999999F3'''''''''''''''
	62318	+ case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
61707	62319	{
61708		- state.addr = 18446744073709547962LLU; // 99999999F4'''''''''''''''
	62320	+ state.addr = 18446744073709547922LLU; // 99999999FR'''''''''''''''
61709	62321	break;
61710	62322	}
61711		- case 18446744073709547962LLU: // 99999999F4'''''''''''''''
	62323	+ case 18446744073709547922LLU: // 99999999FR'''''''''''''''
61712	62324	{
61713		- state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547964LLU : 18446744073709547963LLU;
	62325	+ state.addr = !list_push_move(&heap, &LOCAL_ACCESS(heap.data, 33LLU, 32LLU), &LOCAL_ACCESS(heap.data, 33LLU, 17LLU), 8) ? 18446744073709547924LLU : 18446744073709547923LLU;
61714	62326	break;
61715	62327	}
61716		- case 18446744073709547964LLU: // 99999999F6'''''''''''''''
	62328	+ case 18446744073709547924LLU: // 99999999FT'''''''''''''''
61717	62329	{
61718	62330	{
61719	62331	uint64_t arg = *LOCAL_ACCESS(heap.data, 33LLU, 32LLU);

		@@ -61725,7 +62337,7 @@
61725	62337	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61726	62338	}
61727	62339	// ACCUMULATE ARGUMENTS - END
61728		- uint64_t return_to = 18446744073709547959LLU;
	62340	+ uint64_t return_to = 18446744073709547919LLU;
61729	62341	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61730	62342	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61731	62343	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61734,12 +62346,12 @@
61734	62346	state.addr = 819847183515949359LLU; // reportinit
61735	62347	break;
61736	62348	}
61737		- case 18446744073709547959LLU: // 99999999F1'''''''''''''''
	62349	+ case 18446744073709547919LLU: // 99999999FO'''''''''''''''
61738	62350	{
61739		- state.addr = 18446744073709547960LLU; // 99999999F2'''''''''''''''
	62351	+ state.addr = 18446744073709547920LLU; // 99999999FP'''''''''''''''
61740	62352	break;
61741	62353	}
61742		- case 18446744073709547960LLU: // 99999999F2'''''''''''''''
	62354	+ case 18446744073709547920LLU: // 99999999FP'''''''''''''''
61743	62355	{
61744	62356	fprintf(stderr, "%s", "pushing assignment-destination ");
61745	62357	printid(stderr, /resultid__/*LOCAL_ACCESS(heap.data, 34LLU, 21LLU));

		@@ -61756,7 +62368,7 @@
61756	62368	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61757	62369	}
61758	62370	// ACCUMULATE ARGUMENTS - END
61759		- uint64_t return_to = 18446744073709547958LLU;
	62371	+ uint64_t return_to = 18446744073709547918LLU;
61760	62372	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61761	62373	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61762	62374	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61765,28 +62377,28 @@
61765	62377	state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
61766	62378	break;
61767	62379	}
61768		- case 18446744073709547958LLU: // 99999999F0'''''''''''''''
	62380	+ case 18446744073709547918LLU: // 99999999FN'''''''''''''''
61769	62381	{
61770	62382	(void)LOCAL_POP_MOVE(&heap, 34LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference assignto__ at 34
61771	62383	heap.availilable_size_for_dynamic_objects += 0LLU;
61772	62384	heap.availilable_size_for_dynamic_objects += 0LLU;
61773		- state.addr = 18446744073709547957LLU; // 99999999Fz'''''''''''''''
	62385	+ state.addr = 18446744073709547917LLU; // 99999999FM'''''''''''''''
61774	62386	break;
61775	62387	}
61776		- case 18446744073709547963LLU: // 99999999F5'''''''''''''''
	62388	+ case 18446744073709547923LLU: // 99999999FS'''''''''''''''
61777	62389	{
61778		- state.addr = 18446744073709547957LLU; // 99999999Fz'''''''''''''''
	62390	+ state.addr = 18446744073709547917LLU; // 99999999FM'''''''''''''''
61779	62391	break;
61780	62392	}
61781		- case 18446744073709547957LLU: // 99999999Fz'''''''''''''''
	62393	+ case 18446744073709547917LLU: // 99999999FM'''''''''''''''
61782	62394	{
61783	62395	// variable resdest___ __________ goes out of scope
61784	62396	// (uninitialized -> no destructor-call)
61785	62397	(void)LOCAL_POP_MOVE(&heap, 33LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference __________ at 33
61786		- state.addr = 18446744073709547965LLU; // 99999999F7'''''''''''''''
	62398	+ state.addr = 18446744073709547925LLU; // 99999999FU'''''''''''''''
61787	62399	break;
61788	62400	}
61789		- case 18446744073709547965LLU: // 99999999F7'''''''''''''''
	62401	+ case 18446744073709547925LLU: // 99999999FU'''''''''''''''
61790	62402	{
61791	62403	// variable u64 callee_id_ goes out of scope
61792	62404	// emitted destructur for type u64

		@@ -61818,10 +62430,10 @@
61818	62430	// variable type______ type______ goes out of scope
61819	62431	// (uninitialized -> no destructor-call)
61820	62432	(void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 23
61821		- state.addr = 18446744073709548001LLU; // 99999999Gf'''''''''''''''
	62433	+ state.addr = 18446744073709547961LLU; // 99999999F3'''''''''''''''
61822	62434	break;
61823	62435	}
61824		- case 18446744073709548001LLU: // 99999999Gf'''''''''''''''
	62436	+ case 18446744073709547961LLU: // 99999999F3'''''''''''''''
61825	62437	{
61826	62438	// ACCUMULATE ARGUMENTS - BEGIN
61827	62439	{

		@@ -61829,7 +62441,7 @@
61829	62441	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61830	62442	}
61831	62443	// ACCUMULATE ARGUMENTS - END
61832		- uint64_t return_to = 18446744073709547955LLU;
	62444	+ uint64_t return_to = 18446744073709547915LLU;
61833	62445	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61834	62446	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61835	62447	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61838,32 +62450,32 @@
61838	62450	state.addr = 839519719621918720LLU; // skipws____
61839	62451	break;
61840	62452	}
61841		- case 18446744073709547955LLU: // 99999999Fx'''''''''''''''
	62453	+ case 18446744073709547915LLU: // 99999999FK'''''''''''''''
61842	62454	{
61843		- state.addr = 18446744073709547956LLU; // 99999999Fy'''''''''''''''
	62455	+ state.addr = 18446744073709547916LLU; // 99999999FL'''''''''''''''
61844	62456	break;
61845	62457	}
61846		- case 18446744073709547956LLU: // 99999999Fy'''''''''''''''
	62458	+ case 18446744073709547916LLU: // 99999999FL'''''''''''''''
61847	62459	{
61848	62460	/result____/LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /separator_/LOCAL_ACCESS(heap.data, 22LLU, 18LLU) != /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
61849		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547954LLU : 18446744073709547953LLU;
	62461	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547914LLU : 18446744073709547913LLU;
61850	62462	break;
61851	62463	}
61852		- case 18446744073709547954LLU: // 99999999Fw'''''''''''''''
	62464	+ case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
61853	62465	{
61854	62466	/result____/LOCAL_ACCESS(heap.data, 22LLU, 20LLU) = /terminator/LOCAL_ACCESS(heap.data, 22LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU));
61855		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547952LLU : 18446744073709547951LLU;
	62467	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 20LLU) ? 18446744073709547912LLU : 18446744073709547911LLU;
61856	62468	break;
61857	62469	}
61858		- case 18446744073709547952LLU: // 99999999Fu'''''''''''''''
	62470	+ case 18446744073709547912LLU: // 99999999FH'''''''''''''''
61859	62471	{
61860	62472	ungetc(0, stdin);
61861	62473	heap.availilable_size_for_dynamic_objects += 0LLU;
61862	62474	heap.availilable_size_for_dynamic_objects += 0LLU;
61863		- state.addr = 18446744073709547950LLU; // 99999999Fs'''''''''''''''
	62475	+ state.addr = 18446744073709547910LLU; // 99999999FF'''''''''''''''
61864	62476	break;
61865	62477	}
61866		- case 18446744073709547951LLU: // 99999999Ft'''''''''''''''
	62478	+ case 18446744073709547911LLU: // 99999999FG'''''''''''''''
61867	62479	{
61868	62480	// ACCUMULATE ARGUMENTS - BEGIN
61869	62481	{

		@@ -61871,7 +62483,7 @@
61871	62483	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61872	62484	}
61873	62485	// ACCUMULATE ARGUMENTS - END
61874		- uint64_t return_to = 18446744073709547948LLU;
	62486	+ uint64_t return_to = 18446744073709547908LLU;
61875	62487	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
61876	62488	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61877	62489	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -61880,12 +62492,12 @@
61880	62492	state.addr = 819847183515949359LLU; // reportinit
61881	62493	break;
61882	62494	}
61883		- case 18446744073709547948LLU: // 99999999Fq'''''''''''''''
	62495	+ case 18446744073709547908LLU: // 99999999FD'''''''''''''''
61884	62496	{
61885		- state.addr = 18446744073709547949LLU; // 99999999Fr'''''''''''''''
	62497	+ state.addr = 18446744073709547909LLU; // 99999999FE'''''''''''''''
61886	62498	break;
61887	62499	}
61888		- case 18446744073709547949LLU: // 99999999Fr'''''''''''''''
	62500	+ case 18446744073709547909LLU: // 99999999FE'''''''''''''''
61889	62501	{
61890	62502	fprintf(stderr, "%s", "expected ',' or ')' but found ");
61891	62503	putc((char)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stderr);

		@@ -61893,15 +62505,15 @@
61893	62505	fprintf(stderr, "%s\n", "");
61894	62506	exit(-1);
61895	62507	}
61896		- state.addr = 18446744073709547950LLU; // 99999999Fs'''''''''''''''
	62508	+ state.addr = 18446744073709547910LLU; // 99999999FF'''''''''''''''
61897	62509	break;
61898	62510	}
61899		- case 18446744073709547950LLU: // 99999999Fs'''''''''''''''
	62511	+ case 18446744073709547910LLU: // 99999999FF'''''''''''''''
61900	62512	{
61901		- state.addr = 18446744073709547953LLU; // 99999999Fv'''''''''''''''
	62513	+ state.addr = 18446744073709547913LLU; // 99999999FI'''''''''''''''
61902	62514	break;
61903	62515	}
61904		- case 18446744073709547953LLU: // 99999999Fv'''''''''''''''
	62516	+ case 18446744073709547913LLU: // 99999999FI'''''''''''''''
61905	62517	{
61906	62518	// variable u64 resultid__ goes out of scope
61907	62519	// emitted destructur for type u64

		@@ -61908,16 +62520,16 @@
61908	62520	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference resultid__ at 22
61909	62521	heap.availilable_size_for_dynamic_objects += 0LLU;
61910	62522	heap.availilable_size_for_dynamic_objects += 0LLU;
61911		- state.addr = 18446744073709547947LLU; // 99999999Fp'''''''''''''''
	62523	+ state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
61912	62524	break;
61913	62525	}
61914		- case 18446744073709548004LLU: // 99999999Gi'''''''''''''''
	62526	+ case 18446744073709547964LLU: // 99999999F6'''''''''''''''
61915	62527	{
61916	62528	ungetc(0, stdin);
61917		- state.addr = 18446744073709547947LLU; // 99999999Fp'''''''''''''''
	62529	+ state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
61918	62530	break;
61919	62531	}
61920		- case 18446744073709547947LLU: // 99999999Fp'''''''''''''''
	62532	+ case 18446744073709547907LLU: // 99999999FC'''''''''''''''
61921	62533	{
61922	62534	// variable u64 result____ goes out of scope
61923	62535	// emitted destructur for type u64

		@@ -61928,10 +62540,10 @@
61928	62540	// variable u64 separator_ goes out of scope
61929	62541	// emitted destructur for type u64
61930	62542	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference separator_ at 19
61931		- state.addr = 18446744073709548009LLU; // 99999999Gn'''''''''''''''
	62543	+ state.addr = 18446744073709547969LLU; // 99999999GA'''''''''''''''
61932	62544	break;
61933	62545	}
61934		- case 18446744073709548008LLU: // 99999999Gm'''''''''''''''
	62546	+ case 18446744073709547968LLU: // 99999999G_'''''''''''''''
61935	62547	{
61936	62548	/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar();
61937	62549	list_reverse(heap.data, &/newresults/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU));

		@@ -61993,7 +62605,7 @@
61993	62605	LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
61994	62606	}
61995	62607	// ACCUMULATE ARGUMENTS - END
61996		- uint64_t return_to = 18446744073709547944LLU;
	62608	+ uint64_t return_to = 18446744073709547904LLU;
61997	62609	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0));
61998	62610	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
61999	62611	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62002,17 +62614,17 @@
62002	62614	state.addr = 533581901720365984LLU; // blockclose
62003	62615	break;
62004	62616	}
62005		- case 18446744073709547944LLU: // 99999999Fm'''''''''''''''
	62617	+ case 18446744073709547904LLU: // 99999999F_'''''''''''''''
62006	62618	{
62007		- state.addr = 18446744073709547945LLU; // 99999999Fn'''''''''''''''
	62619	+ state.addr = 18446744073709547905LLU; // 99999999FA'''''''''''''''
62008	62620	break;
62009	62621	}
62010		- case 18446744073709547945LLU: // 99999999Fn'''''''''''''''
	62622	+ case 18446744073709547905LLU: // 99999999FA'''''''''''''''
62011	62623	{
62012		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547943LLU : 18446744073709547942LLU;
	62624	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709547903LLU : 18446744073709547902LLU;
62013	62625	break;
62014	62626	}
62015		- case 18446744073709547943LLU: // 99999999Fl'''''''''''''''
	62627	+ case 18446744073709547903LLU: // 99999999E9'''''''''''''''
62016	62628	{
62017	62629	fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults");
62018	62630	{

		@@ -62019,10 +62631,10 @@
62019	62631	fprintf(stderr, "%s\n", "");
62020	62632	exit(-1);
62021	62633	}
62022		- state.addr = 18446744073709547942LLU; // 99999999Fk'''''''''''''''
	62634	+ state.addr = 18446744073709547902LLU; // 99999999E8'''''''''''''''
62023	62635	break;
62024	62636	}
62025		- case 18446744073709547942LLU: // 99999999Fk'''''''''''''''
	62637	+ case 18446744073709547902LLU: // 99999999E8'''''''''''''''
62026	62638	{
62027	62639	{
62028	62640	uint64_t arg = 0LLU;

		@@ -62029,10 +62641,10 @@
62029	62641	LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/address of current closure/, &arg);
62030	62642	}
62031	62643	/buf_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) != /ds________/LOCAL_ACCESS(heap.data, 22LLU, 18LLU);
62032		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547941LLU : 18446744073709547940LLU;
	62644	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547901LLU : 18446744073709547900LLU;
62033	62645	break;
62034	62646	}
62035		- case 18446744073709547941LLU: // 99999999Fj'''''''''''''''
	62647	+ case 18446744073709547901LLU: // 99999999E7'''''''''''''''
62036	62648	{
62037	62649	fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch ");
62038	62650	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62041,7 +62653,7 @@
62041	62653	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62042	62654	}
62043	62655	// ACCUMULATE ARGUMENTS - END
62044		- uint64_t return_to = 18446744073709547938LLU;
	62656	+ uint64_t return_to = 18446744073709547898LLU;
62045	62657	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62046	62658	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62047	62659	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62050,12 +62662,12 @@
62050	62662	state.addr = 819847183517274112LLU; // reportnr__
62051	62663	break;
62052	62664	}
62053		- case 18446744073709547938LLU: // 99999999Fg'''''''''''''''
	62665	+ case 18446744073709547898LLU: // 99999999E4'''''''''''''''
62054	62666	{
62055		- state.addr = 18446744073709547939LLU; // 99999999Fh'''''''''''''''
	62667	+ state.addr = 18446744073709547899LLU; // 99999999E5'''''''''''''''
62056	62668	break;
62057	62669	}
62058		- case 18446744073709547939LLU: // 99999999Fh'''''''''''''''
	62670	+ case 18446744073709547899LLU: // 99999999E5'''''''''''''''
62059	62671	{
62060	62672	fprintf(stderr, "%s", " != ");
62061	62673	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62064,7 +62676,7 @@
62064	62676	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62065	62677	}
62066	62678	// ACCUMULATE ARGUMENTS - END
62067		- uint64_t return_to = 18446744073709547936LLU;
	62679	+ uint64_t return_to = 18446744073709547896LLU;
62068	62680	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62069	62681	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62070	62682	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62073,27 +62685,27 @@
62073	62685	state.addr = 819847183517274112LLU; // reportnr__
62074	62686	break;
62075	62687	}
62076		- case 18446744073709547936LLU: // 99999999Fe'''''''''''''''
	62688	+ case 18446744073709547896LLU: // 99999999E2'''''''''''''''
62077	62689	{
62078		- state.addr = 18446744073709547937LLU; // 99999999Ff'''''''''''''''
	62690	+ state.addr = 18446744073709547897LLU; // 99999999E3'''''''''''''''
62079	62691	break;
62080	62692	}
62081		- case 18446744073709547937LLU: // 99999999Ff'''''''''''''''
	62693	+ case 18446744073709547897LLU: // 99999999E3'''''''''''''''
62082	62694	{
62083	62695	{
62084	62696	fprintf(stderr, "%s\n", "");
62085	62697	exit(-1);
62086	62698	}
62087		- state.addr = 18446744073709547940LLU; // 99999999Fi'''''''''''''''
	62699	+ state.addr = 18446744073709547900LLU; // 99999999E6'''''''''''''''
62088	62700	break;
62089	62701	}
62090		- case 18446744073709547940LLU: // 99999999Fi'''''''''''''''
	62702	+ case 18446744073709547900LLU: // 99999999E6'''''''''''''''
62091	62703	{
62092	62704	/buf_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 14LLU)) != /rs________/LOCAL_ACCESS(heap.data, 22LLU, 19LLU);
62093		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547935LLU : 18446744073709547934LLU;
	62705	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547895LLU : 18446744073709547894LLU;
62094	62706	break;
62095	62707	}
62096		- case 18446744073709547935LLU: // 99999999Fd'''''''''''''''
	62708	+ case 18446744073709547895LLU: // 99999999E1'''''''''''''''
62097	62709	{
62098	62710	fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch ");
62099	62711	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62102,7 +62714,7 @@
62102	62714	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62103	62715	}
62104	62716	// ACCUMULATE ARGUMENTS - END
62105		- uint64_t return_to = 18446744073709547932LLU;
	62717	+ uint64_t return_to = 18446744073709547892LLU;
62106	62718	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62107	62719	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62108	62720	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62111,12 +62723,12 @@
62111	62723	state.addr = 819847183517274112LLU; // reportnr__
62112	62724	break;
62113	62725	}
62114		- case 18446744073709547932LLU: // 99999999Fa'''''''''''''''
	62726	+ case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
62115	62727	{
62116		- state.addr = 18446744073709547933LLU; // 99999999Fb'''''''''''''''
	62728	+ state.addr = 18446744073709547893LLU; // 99999999Ez'''''''''''''''
62117	62729	break;
62118	62730	}
62119		- case 18446744073709547933LLU: // 99999999Fb'''''''''''''''
	62731	+ case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
62120	62732	{
62121	62733	fprintf(stderr, "%s", " != ");
62122	62734	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62125,7 +62737,7 @@
62125	62737	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62126	62738	}
62127	62739	// ACCUMULATE ARGUMENTS - END
62128		- uint64_t return_to = 18446744073709547930LLU;
	62740	+ uint64_t return_to = 18446744073709547890LLU;
62129	62741	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62130	62742	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62131	62743	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62134,27 +62746,27 @@
62134	62746	state.addr = 819847183517274112LLU; // reportnr__
62135	62747	break;
62136	62748	}
62137		- case 18446744073709547930LLU: // 99999999FZ'''''''''''''''
	62749	+ case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
62138	62750	{
62139		- state.addr = 18446744073709547931LLU; // 99999999F$'''''''''''''''
	62751	+ state.addr = 18446744073709547891LLU; // 99999999Ex'''''''''''''''
62140	62752	break;
62141	62753	}
62142		- case 18446744073709547931LLU: // 99999999F$'''''''''''''''
	62754	+ case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
62143	62755	{
62144	62756	{
62145	62757	fprintf(stderr, "%s\n", "");
62146	62758	exit(-1);
62147	62759	}
62148		- state.addr = 18446744073709547934LLU; // 99999999Fc'''''''''''''''
	62760	+ state.addr = 18446744073709547894LLU; // 99999999E0'''''''''''''''
62149	62761	break;
62150	62762	}
62151		- case 18446744073709547934LLU: // 99999999Fc'''''''''''''''
	62763	+ case 18446744073709547894LLU: // 99999999E0'''''''''''''''
62152	62764	{
62153	62765	/buf_______/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /remainheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 22LLU, 15LLU)) != /rh________/LOCAL_ACCESS(heap.data, 22LLU, 20LLU);
62154		- state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547929LLU : 18446744073709547928LLU;
	62766	+ state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709547889LLU : 18446744073709547888LLU;
62155	62767	break;
62156	62768	}
62157		- case 18446744073709547929LLU: // 99999999FY'''''''''''''''
	62769	+ case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
62158	62770	{
62159	62771	fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch ");
62160	62772	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62163,7 +62775,7 @@
62163	62775	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62164	62776	}
62165	62777	// ACCUMULATE ARGUMENTS - END
62166		- uint64_t return_to = 18446744073709547926LLU;
	62778	+ uint64_t return_to = 18446744073709547886LLU;
62167	62779	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62168	62780	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62169	62781	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62172,12 +62784,12 @@
62172	62784	state.addr = 819847183517274112LLU; // reportnr__
62173	62785	break;
62174	62786	}
62175		- case 18446744073709547926LLU: // 99999999FV'''''''''''''''
	62787	+ case 18446744073709547886LLU: // 99999999Es'''''''''''''''
62176	62788	{
62177		- state.addr = 18446744073709547927LLU; // 99999999FW'''''''''''''''
	62789	+ state.addr = 18446744073709547887LLU; // 99999999Et'''''''''''''''
62178	62790	break;
62179	62791	}
62180		- case 18446744073709547927LLU: // 99999999FW'''''''''''''''
	62792	+ case 18446744073709547887LLU: // 99999999Et'''''''''''''''
62181	62793	{
62182	62794	fprintf(stderr, "%s", " != ");
62183	62795	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62186,7 +62798,7 @@
62186	62798	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62187	62799	}
62188	62800	// ACCUMULATE ARGUMENTS - END
62189		- uint64_t return_to = 18446744073709547924LLU;
	62801	+ uint64_t return_to = 18446744073709547884LLU;
62190	62802	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62191	62803	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62192	62804	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62195,21 +62807,21 @@
62195	62807	state.addr = 819847183517274112LLU; // reportnr__
62196	62808	break;
62197	62809	}
62198		- case 18446744073709547924LLU: // 99999999FT'''''''''''''''
	62810	+ case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
62199	62811	{
62200		- state.addr = 18446744073709547925LLU; // 99999999FU'''''''''''''''
	62812	+ state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
62201	62813	break;
62202	62814	}
62203		- case 18446744073709547925LLU: // 99999999FU'''''''''''''''
	62815	+ case 18446744073709547885LLU: // 99999999Er'''''''''''''''
62204	62816	{
62205	62817	{
62206	62818	fprintf(stderr, "%s\n", "");
62207	62819	exit(-1);
62208	62820	}
62209		- state.addr = 18446744073709547928LLU; // 99999999FX'''''''''''''''
	62821	+ state.addr = 18446744073709547888LLU; // 99999999Eu'''''''''''''''
62210	62822	break;
62211	62823	}
62212		- case 18446744073709547928LLU: // 99999999FX'''''''''''''''
	62824	+ case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
62213	62825	{
62214	62826	// variable u64 buf_______ goes out of scope
62215	62827	// emitted destructur for type u64

		@@ -62223,10 +62835,10 @@
62223	62835	// variable u64 ds________ goes out of scope
62224	62836	// emitted destructur for type u64
62225	62837	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ds________ at 19
62226		- state.addr = 18446744073709547946LLU; // 99999999Fo'''''''''''''''
	62838	+ state.addr = 18446744073709547906LLU; // 99999999FB'''''''''''''''
62227	62839	break;
62228	62840	}
62229		- case 18446744073709547946LLU: // 99999999Fo'''''''''''''''
	62841	+ case 18446744073709547906LLU: // 99999999FB'''''''''''''''
62230	62842	{
62231	62843	// ACCUMULATE ARGUMENTS - BEGIN
62232	62844	{

		@@ -62234,7 +62846,7 @@
62234	62846	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62235	62847	}
62236	62848	// ACCUMULATE ARGUMENTS - END
62237		- uint64_t return_to = 18446744073709547922LLU;
	62849	+ uint64_t return_to = 18446744073709547882LLU;
62238	62850	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62239	62851	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62240	62852	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62243,12 +62855,12 @@
62243	62855	state.addr = 839519719621918720LLU; // skipws____
62244	62856	break;
62245	62857	}
62246		- case 18446744073709547922LLU: // 99999999FR'''''''''''''''
	62858	+ case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
62247	62859	{
62248		- state.addr = 18446744073709547923LLU; // 99999999FS'''''''''''''''
	62860	+ state.addr = 18446744073709547883LLU; // 99999999Ep'''''''''''''''
62249	62861	break;
62250	62862	}
62251		- case 18446744073709547923LLU: // 99999999FS'''''''''''''''
	62863	+ case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
62252	62864	{
62253	62865	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 11LLU)));
62254	62866	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62321,7 +62933,7 @@
62321	62933	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62322	62934	}
62323	62935	// ACCUMULATE ARGUMENTS - END
62324		- uint64_t return_to = 18446744073709547920LLU;
	62936	+ uint64_t return_to = 18446744073709547880LLU;
62325	62937	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
62326	62938	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62327	62939	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62330,23 +62942,23 @@
62330	62942	state.addr = 787472338545441824LLU; // procrvalue
62331	62943	break;
62332	62944	}
62333		- case 18446744073709547920LLU: // 99999999FP'''''''''''''''
	62945	+ case 18446744073709547880LLU: // 99999999Em'''''''''''''''
62334	62946	{
62335		- state.addr = 18446744073709547921LLU; // 99999999FQ'''''''''''''''
	62947	+ state.addr = 18446744073709547881LLU; // 99999999En'''''''''''''''
62336	62948	break;
62337	62949	}
62338		- case 18446744073709547921LLU: // 99999999FQ'''''''''''''''
	62950	+ case 18446744073709547881LLU: // 99999999En'''''''''''''''
62339	62951	{
62340	62952	// variable list<resdest___> newresults goes out of scope
62341	62953	// emitted destructur for type list<resdest___>
62342		- state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
	62954	+ state.addr = 18446744073709547878LLU; // 99999999Ek'''''''''''''''
62343	62955	break;
62344	62956	}
62345		- case 18446744073709547918LLU: // 99999999FN'''''''''''''''
	62957	+ case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
62346	62958	{
62347	62959	if(!LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/list*/)
62348	62960	{
62349		- state.addr = 18446744073709547919LLU; // 99999999FO'''''''''''''''
	62961	+ state.addr = 18446744073709547879LLU; // 99999999El'''''''''''''''
62350	62962	break;
62351	62963	}
62352	62964	// temporary list-element

		@@ -62360,7 +62972,7 @@
62360	62972	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62361	62973	}
62362	62974	// ACCUMULATE ARGUMENTS - END
62363		- uint64_t return_to = 18446744073709547917LLU;
	62975	+ uint64_t return_to = 18446744073709547877LLU;
62364	62976	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62365	62977	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62366	62978	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62369,26 +62981,26 @@
62369	62981	state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
62370	62982	break;
62371	62983	}
62372		- case 18446744073709547917LLU: // 99999999FM'''''''''''''''
	62984	+ case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
62373	62985	{
62374	62986	// RELEASE temporary destructor-variable
62375	62987	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 19
62376		- state.addr = 18446744073709547918LLU; // 99999999FN'''''''''''''''
	62988	+ state.addr = 18446744073709547878LLU; // 99999999Ek'''''''''''''''
62377	62989	break;
62378	62990	}
62379		- case 18446744073709547919LLU: // 99999999FO'''''''''''''''
	62991	+ case 18446744073709547879LLU: // 99999999El'''''''''''''''
62380	62992	{
62381	62993	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 18
62382	62994	// variable list<resdest___> tmpresults goes out of scope
62383	62995	// emitted destructur for type list<resdest___>
62384		- state.addr = 18446744073709547915LLU; // 99999999FK'''''''''''''''
	62996	+ state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
62385	62997	break;
62386	62998	}
62387		- case 18446744073709547915LLU: // 99999999FK'''''''''''''''
	62999	+ case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
62388	63000	{
62389	63001	if(!LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/list*/)
62390	63002	{
62391		- state.addr = 18446744073709547916LLU; // 99999999FL'''''''''''''''
	63003	+ state.addr = 18446744073709547876LLU; // 99999999Ei'''''''''''''''
62392	63004	break;
62393	63005	}
62394	63006	// temporary list-element

		@@ -62402,7 +63014,7 @@
62402	63014	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62403	63015	}
62404	63016	// ACCUMULATE ARGUMENTS - END
62405		- uint64_t return_to = 18446744073709547914LLU;
	63017	+ uint64_t return_to = 18446744073709547874LLU;
62406	63018	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62407	63019	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62408	63020	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62411,14 +63023,14 @@
62411	63023	state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
62412	63024	break;
62413	63025	}
62414		- case 18446744073709547914LLU: // 99999999FJ'''''''''''''''
	63026	+ case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
62415	63027	{
62416	63028	// RELEASE temporary destructor-variable
62417	63029	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 18
62418		- state.addr = 18446744073709547915LLU; // 99999999FK'''''''''''''''
	63030	+ state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
62419	63031	break;
62420	63032	}
62421		- case 18446744073709547916LLU: // 99999999FL'''''''''''''''
	63033	+ case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
62422	63034	{
62423	63035	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmpresults at 17
62424	63036	// parameter-reference u64 remainheap goes out of scope

		@@ -62473,7 +63085,7 @@
62473	63085	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62474	63086	}
62475	63087	// ACCUMULATE ARGUMENTS - END
62476		- uint64_t return_to = 18446744073709547912LLU;
	63088	+ uint64_t return_to = 18446744073709547872LLU;
62477	63089	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62478	63090	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62479	63091	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62482,12 +63094,12 @@
62482	63094	state.addr = 839519719621918720LLU; // skipws____
62483	63095	break;
62484	63096	}
62485		- case 18446744073709547912LLU: // 99999999FH'''''''''''''''
	63097	+ case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
62486	63098	{
62487		- state.addr = 18446744073709547913LLU; // 99999999FI'''''''''''''''
	63099	+ state.addr = 18446744073709547873LLU; // 99999999Ef'''''''''''''''
62488	63100	break;
62489	63101	}
62490		- case 18446744073709547913LLU: // 99999999FI'''''''''''''''
	63102	+ case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
62491	63103	{
62492	63104	/id________/LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 10LLU)));
62493	63105	{

		@@ -62516,7 +63128,7 @@
62516	63128	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62517	63129	}
62518	63130	// ACCUMULATE ARGUMENTS - END
62519		- uint64_t return_to = 18446744073709547910LLU;
	63131	+ uint64_t return_to = 18446744073709547870LLU;
62520	63132	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
62521	63133	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62522	63134	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62525,12 +63137,12 @@
62525	63137	state.addr = 782701543487916768LLU; // parsemtype
62526	63138	break;
62527	63139	}
62528		- case 18446744073709547910LLU: // 99999999FF'''''''''''''''
	63140	+ case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
62529	63141	{
62530		- state.addr = 18446744073709547911LLU; // 99999999FG'''''''''''''''
	63142	+ state.addr = 18446744073709547871LLU; // 99999999Ed'''''''''''''''
62531	63143	break;
62532	63144	}
62533		- case 18446744073709547911LLU: // 99999999FG'''''''''''''''
	63145	+ case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
62534	63146	{
62535	63147	// ACCUMULATE ARGUMENTS - BEGIN
62536	63148	{

		@@ -62538,7 +63150,7 @@
62538	63150	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62539	63151	}
62540	63152	// ACCUMULATE ARGUMENTS - END
62541		- uint64_t return_to = 18446744073709547908LLU;
	63153	+ uint64_t return_to = 18446744073709547868LLU;
62542	63154	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62543	63155	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62544	63156	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62547,12 +63159,12 @@
62547	63159	state.addr = 839519719621918720LLU; // skipws____
62548	63160	break;
62549	63161	}
62550		- case 18446744073709547908LLU: // 99999999FD'''''''''''''''
	63162	+ case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
62551	63163	{
62552		- state.addr = 18446744073709547909LLU; // 99999999FE'''''''''''''''
	63164	+ state.addr = 18446744073709547869LLU; // 99999999Eb'''''''''''''''
62553	63165	break;
62554	63166	}
62555		- case 18446744073709547909LLU: // 99999999FE'''''''''''''''
	63167	+ case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
62556	63168	{
62557	63169	/id________/LOCAL_ACCESS(heap.data, 18LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 10LLU)));
62558	63170	{

		@@ -62577,7 +63189,7 @@
62577	63189	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62578	63190	}
62579	63191	// ACCUMULATE ARGUMENTS - END
62580		- uint64_t return_to = 18446744073709547906LLU;
	63192	+ uint64_t return_to = 18446744073709547866LLU;
62581	63193	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
62582	63194	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62583	63195	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62586,17 +63198,17 @@
62586	63198	state.addr = 696275824427849761LLU; // knowvarref
62587	63199	break;
62588	63200	}
62589		- case 18446744073709547906LLU: // 99999999FB'''''''''''''''
	63201	+ case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
62590	63202	{
62591		- state.addr = 18446744073709547907LLU; // 99999999FC'''''''''''''''
	63203	+ state.addr = 18446744073709547867LLU; // 99999999E$'''''''''''''''
62592	63204	break;
62593	63205	}
62594		- case 18446744073709547907LLU: // 99999999FC'''''''''''''''
	63206	+ case 18446744073709547867LLU: // 99999999E$'''''''''''''''
62595	63207	{
62596		- state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709547905LLU : 18446744073709547904LLU;
	63208	+ state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709547865LLU : 18446744073709547864LLU;
62597	63209	break;
62598	63210	}
62599		- case 18446744073709547905LLU: // 99999999FA'''''''''''''''
	63211	+ case 18446744073709547865LLU: // 99999999EY'''''''''''''''
62600	63212	{
62601	63213	{
62602	63214	uint64_t arg = 0LLU;

		@@ -62608,7 +63220,7 @@
62608	63220	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62609	63221	}
62610	63222	// ACCUMULATE ARGUMENTS - END
62611		- uint64_t return_to = 18446744073709547902LLU;
	63223	+ uint64_t return_to = 18446744073709547862LLU;
62612	63224	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62613	63225	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62614	63226	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62617,12 +63229,12 @@
62617	63229	state.addr = 839519719621918720LLU; // skipws____
62618	63230	break;
62619	63231	}
62620		- case 18446744073709547902LLU: // 99999999E8'''''''''''''''
	63232	+ case 18446744073709547862LLU: // 99999999EV'''''''''''''''
62621	63233	{
62622		- state.addr = 18446744073709547903LLU; // 99999999E9'''''''''''''''
	63234	+ state.addr = 18446744073709547863LLU; // 99999999EW'''''''''''''''
62623	63235	break;
62624	63236	}
62625		- case 18446744073709547903LLU: // 99999999E9'''''''''''''''
	63237	+ case 18446744073709547863LLU: // 99999999EW'''''''''''''''
62626	63238	{
62627	63239	/buf_______/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
62628	63240	{

		@@ -62630,17 +63242,17 @@
62630	63242	LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/address of current closure/, &arg);
62631	63243	}
62632	63244	/shadow____/LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /buf_______/LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /shadow____/*LOCAL_ACCESS(heap.data, 21LLU, 20LLU);
62633		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547901LLU : 18446744073709547900LLU;
	63245	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547861LLU : 18446744073709547860LLU;
62634	63246	break;
62635	63247	}
62636		- case 18446744073709547901LLU: // 99999999E7'''''''''''''''
	63248	+ case 18446744073709547861LLU: // 99999999EU'''''''''''''''
62637	63249	{
62638	63250	heap.availilable_size_for_dynamic_objects += 0LLU;
62639	63251	heap.availilable_size_for_dynamic_objects += 0LLU;
62640		- state.addr = 18446744073709547899LLU; // 99999999E5'''''''''''''''
	63252	+ state.addr = 18446744073709547859LLU; // 99999999ES'''''''''''''''
62641	63253	break;
62642	63254	}
62643		- case 18446744073709547900LLU: // 99999999E6'''''''''''''''
	63255	+ case 18446744073709547860LLU: // 99999999ET'''''''''''''''
62644	63256	{
62645	63257	// ACCUMULATE ARGUMENTS - BEGIN
62646	63258	{

		@@ -62648,7 +63260,7 @@
62648	63260	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62649	63261	}
62650	63262	// ACCUMULATE ARGUMENTS - END
62651		- uint64_t return_to = 18446744073709547897LLU;
	63263	+ uint64_t return_to = 18446744073709547857LLU;
62652	63264	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62653	63265	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62654	63266	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62657,12 +63269,12 @@
62657	63269	state.addr = 819847183515949359LLU; // reportinit
62658	63270	break;
62659	63271	}
62660		- case 18446744073709547897LLU: // 99999999E3'''''''''''''''
	63272	+ case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
62661	63273	{
62662		- state.addr = 18446744073709547898LLU; // 99999999E4'''''''''''''''
	63274	+ state.addr = 18446744073709547858LLU; // 99999999ER'''''''''''''''
62663	63275	break;
62664	63276	}
62665		- case 18446744073709547898LLU: // 99999999E4'''''''''''''''
	63277	+ case 18446744073709547858LLU: // 99999999ER'''''''''''''''
62666	63278	{
62667	63279	fprintf(stderr, "%s", "variable ");
62668	63280	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 21LLU, 15LLU));

		@@ -62672,10 +63284,10 @@
62672	63284	fprintf(stderr, "%s\n", "");
62673	63285	exit(-1);
62674	63286	}
62675		- state.addr = 18446744073709547899LLU; // 99999999E5'''''''''''''''
	63287	+ state.addr = 18446744073709547859LLU; // 99999999ES'''''''''''''''
62676	63288	break;
62677	63289	}
62678		- case 18446744073709547899LLU: // 99999999E5'''''''''''''''
	63290	+ case 18446744073709547859LLU: // 99999999ES'''''''''''''''
62679	63291	{
62680	63292	// variable u64 shadow____ goes out of scope
62681	63293	// emitted destructur for type u64

		@@ -62683,10 +63295,10 @@
62683	63295	// variable u64 buf_______ goes out of scope
62684	63296	// emitted destructur for type u64
62685	63297	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference buf_______ at 20
62686		- state.addr = 18446744073709547904LLU; // 99999999F_'''''''''''''''
	63298	+ state.addr = 18446744073709547864LLU; // 99999999EX'''''''''''''''
62687	63299	break;
62688	63300	}
62689		- case 18446744073709547904LLU: // 99999999F_'''''''''''''''
	63301	+ case 18446744073709547864LLU: // 99999999EX'''''''''''''''
62690	63302	{
62691	63303	// ACCUMULATE ARGUMENTS - BEGIN
62692	63304	{

		@@ -62710,7 +63322,7 @@
62710	63322	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62711	63323	}
62712	63324	// ACCUMULATE ARGUMENTS - END
62713		- uint64_t return_to = 18446744073709547895LLU;
	63325	+ uint64_t return_to = 18446744073709547855LLU;
62714	63326	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
62715	63327	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62716	63328	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62719,12 +63331,12 @@
62719	63331	state.addr = 515555125197130432LLU; // allocheap_
62720	63332	break;
62721	63333	}
62722		- case 18446744073709547895LLU: // 99999999E1'''''''''''''''
	63334	+ case 18446744073709547855LLU: // 99999999EO'''''''''''''''
62723	63335	{
62724		- state.addr = 18446744073709547896LLU; // 99999999E2'''''''''''''''
	63336	+ state.addr = 18446744073709547856LLU; // 99999999EP'''''''''''''''
62725	63337	break;
62726	63338	}
62727		- case 18446744073709547896LLU: // 99999999E2'''''''''''''''
	63339	+ case 18446744073709547856LLU: // 99999999EP'''''''''''''''
62728	63340	{
62729	63341	// ACCUMULATE ARGUMENTS - BEGIN
62730	63342	{

		@@ -62732,7 +63344,7 @@
62732	63344	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62733	63345	}
62734	63346	// ACCUMULATE ARGUMENTS - END
62735		- uint64_t return_to = 18446744073709547892LLU;
	63347	+ uint64_t return_to = 18446744073709547852LLU;
62736	63348	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62737	63349	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62738	63350	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62741,12 +63353,12 @@
62741	63353	state.addr = 839519719621918720LLU; // skipws____
62742	63354	break;
62743	63355	}
62744		- case 18446744073709547892LLU: // 99999999Ey'''''''''''''''
	63356	+ case 18446744073709547852LLU: // 99999999EL'''''''''''''''
62745	63357	{
62746		- state.addr = 18446744073709547893LLU; // 99999999Ez'''''''''''''''
	63358	+ state.addr = 18446744073709547853LLU; // 99999999EM'''''''''''''''
62747	63359	break;
62748	63360	}
62749		- case 18446744073709547893LLU: // 99999999Ez'''''''''''''''
	63361	+ case 18446744073709547853LLU: // 99999999EM'''''''''''''''
62750	63362	{
62751	63363	matchid("=", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 10LLU)));
62752	63364	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62755,7 +63367,7 @@
62755	63367	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62756	63368	}
62757	63369	// ACCUMULATE ARGUMENTS - END
62758		- uint64_t return_to = 18446744073709547890LLU;
	63370	+ uint64_t return_to = 18446744073709547850LLU;
62759	63371	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62760	63372	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62761	63373	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62764,12 +63376,12 @@
62764	63376	state.addr = 839519719621918720LLU; // skipws____
62765	63377	break;
62766	63378	}
62767		- case 18446744073709547890LLU: // 99999999Ew'''''''''''''''
	63379	+ case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
62768	63380	{
62769		- state.addr = 18446744073709547891LLU; // 99999999Ex'''''''''''''''
	63381	+ state.addr = 18446744073709547851LLU; // 99999999EK'''''''''''''''
62770	63382	break;
62771	63383	}
62772		- case 18446744073709547891LLU: // 99999999Ex'''''''''''''''
	63384	+ case 18446744073709547851LLU: // 99999999EK'''''''''''''''
62773	63385	{
62774	63386	{
62775	63387	uint64_t arg = 0LLU;

		@@ -62778,10 +63390,10 @@
62778	63390	*LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 59LLU;
62779	63391
62780	63392	/buf_______/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /buf_______/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) == /c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 10LLU));
62781		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547889LLU : 18446744073709547888LLU;
	63393	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547849LLU : 18446744073709547848LLU;
62782	63394	break;
62783	63395	}
62784		- case 18446744073709547889LLU: // 99999999Ev'''''''''''''''
	63396	+ case 18446744073709547849LLU: // 99999999EI'''''''''''''''
62785	63397	{
62786	63398	matchid(";", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
62787	63399	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62794,7 +63406,7 @@
62794	63406	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62795	63407	}
62796	63408	// ACCUMULATE ARGUMENTS - END
62797		- uint64_t return_to = 18446744073709547886LLU;
	63409	+ uint64_t return_to = 18446744073709547846LLU;
62798	63410	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
62799	63411	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62800	63412	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62803,12 +63415,12 @@
62803	63415	state.addr = 517555565476695680LLU; // assertu64_
62804	63416	break;
62805	63417	}
62806		- case 18446744073709547886LLU: // 99999999Es'''''''''''''''
	63418	+ case 18446744073709547846LLU: // 99999999EF'''''''''''''''
62807	63419	{
62808		- state.addr = 18446744073709547887LLU; // 99999999Et'''''''''''''''
	63420	+ state.addr = 18446744073709547847LLU; // 99999999EG'''''''''''''''
62809	63421	break;
62810	63422	}
62811		- case 18446744073709547887LLU: // 99999999Et'''''''''''''''
	63423	+ case 18446744073709547847LLU: // 99999999EG'''''''''''''''
62812	63424	{
62813	63425	{
62814	63426	uint64_t arg = 0LLU;

		@@ -62816,7 +63428,7 @@
62816	63428	}
62817	63429	// ACCUMULATE ARGUMENTS - BEGIN
62818	63430	// ACCUMULATE ARGUMENTS - END
62819		- uint64_t return_to = 18446744073709547884LLU;
	63431	+ uint64_t return_to = 18446744073709547844LLU;
62820	63432	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
62821	63433	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62822	63434	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62825,12 +63437,12 @@
62825	63437	state.addr = 890787671342055424LLU; // varopen___
62826	63438	break;
62827	63439	}
62828		- case 18446744073709547884LLU: // 99999999Eq'''''''''''''''
	63440	+ case 18446744073709547844LLU: // 99999999ED'''''''''''''''
62829	63441	{
62830		- state.addr = 18446744073709547885LLU; // 99999999Er'''''''''''''''
	63442	+ state.addr = 18446744073709547845LLU; // 99999999EE'''''''''''''''
62831	63443	break;
62832	63444	}
62833		- case 18446744073709547885LLU: // 99999999Er'''''''''''''''
	63445	+ case 18446744073709547845LLU: // 99999999EE'''''''''''''''
62834	63446	{
62835	63447	fprintf(stdout, "%s", "0");
62836	63448	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -62855,7 +63467,7 @@
62855	63467	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62856	63468	}
62857	63469	// ACCUMULATE ARGUMENTS - END
62858		- uint64_t return_to = 18446744073709547882LLU;
	63470	+ uint64_t return_to = 18446744073709547842LLU;
62859	63471	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
62860	63472	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62861	63473	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62864,12 +63476,12 @@
62864	63476	state.addr = 890786842582581248LLU; // varclose__
62865	63477	break;
62866	63478	}
62867		- case 18446744073709547882LLU: // 99999999Eo'''''''''''''''
	63479	+ case 18446744073709547842LLU: // 99999999EB'''''''''''''''
62868	63480	{
62869		- state.addr = 18446744073709547883LLU; // 99999999Ep'''''''''''''''
	63481	+ state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
62870	63482	break;
62871	63483	}
62872		- case 18446744073709547883LLU: // 99999999Ep'''''''''''''''
	63484	+ case 18446744073709547843LLU: // 99999999EC'''''''''''''''
62873	63485	{
62874	63486	{
62875	63487	uint64_t arg = 0LLU;

		@@ -62893,7 +63505,7 @@
62893	63505	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62894	63506	}
62895	63507	// ACCUMULATE ARGUMENTS - END
62896		- uint64_t return_to = 18446744073709547879LLU;
	63508	+ uint64_t return_to = 18446744073709547839LLU;
62897	63509	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
62898	63510	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62899	63511	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62902,12 +63514,12 @@
62902	63514	state.addr = 367395560426147840LLU; // TYPECOPY__
62903	63515	break;
62904	63516	}
62905		- case 18446744073709547879LLU: // 99999999El'''''''''''''''
	63517	+ case 18446744073709547839LLU: // 99999999D9'''''''''''''''
62906	63518	{
62907		- state.addr = 18446744073709547880LLU; // 99999999Em'''''''''''''''
	63519	+ state.addr = 18446744073709547840LLU; // 99999999E_'''''''''''''''
62908	63520	break;
62909	63521	}
62910		- case 18446744073709547880LLU: // 99999999Em'''''''''''''''
	63522	+ case 18446744073709547840LLU: // 99999999E_'''''''''''''''
62911	63523	{
62912	63524	// ACCUMULATE ARGUMENTS - BEGIN
62913	63525	{

		@@ -62939,7 +63551,7 @@
62939	63551	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62940	63552	}
62941	63553	// ACCUMULATE ARGUMENTS - END
62942		- uint64_t return_to = 18446744073709547877LLU;
	63554	+ uint64_t return_to = 18446744073709547837LLU;
62943	63555	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
62944	63556	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62945	63557	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62948,12 +63560,12 @@
62948	63560	state.addr = 788334703205941248LLU; // pushvar___
62949	63561	break;
62950	63562	}
62951		- case 18446744073709547877LLU: // 99999999Ej'''''''''''''''
	63563	+ case 18446744073709547837LLU: // 99999999D7'''''''''''''''
62952	63564	{
62953		- state.addr = 18446744073709547878LLU; // 99999999Ek'''''''''''''''
	63565	+ state.addr = 18446744073709547838LLU; // 99999999D8'''''''''''''''
62954	63566	break;
62955	63567	}
62956		- case 18446744073709547878LLU: // 99999999Ek'''''''''''''''
	63568	+ case 18446744073709547838LLU: // 99999999D8'''''''''''''''
62957	63569	{
62958	63570	// variable type______ t_________ goes out of scope
62959	63571	// emitted destructur for type type______

		@@ -62963,7 +63575,7 @@
62963	63575	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
62964	63576	}
62965	63577	// ACCUMULATE ARGUMENTS - END
62966		- uint64_t return_to = 18446744073709547876LLU;
	63578	+ uint64_t return_to = 18446744073709547836LLU;
62967	63579	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
62968	63580	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
62969	63581	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -62972,7 +63584,7 @@
62972	63584	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
62973	63585	break;
62974	63586	}
62975		- case 18446744073709547876LLU: // 99999999Ei'''''''''''''''
	63587	+ case 18446744073709547836LLU: // 99999999D6'''''''''''''''
62976	63588	{
62977	63589	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 24
62978	63590	// variable u64 initialize goes out of scope

		@@ -62981,10 +63593,10 @@
62981	63593	// variable u64 INDIRECT__ goes out of scope
62982	63594	// emitted destructur for type u64
62983	63595	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 22
62984		- state.addr = 18446744073709547881LLU; // 99999999En'''''''''''''''
	63596	+ state.addr = 18446744073709547841LLU; // 99999999EA'''''''''''''''
62985	63597	break;
62986	63598	}
62987		- case 18446744073709547881LLU: // 99999999En'''''''''''''''
	63599	+ case 18446744073709547841LLU: // 99999999EA'''''''''''''''
62988	63600	{
62989	63601	// variable u64 varidx____ goes out of scope
62990	63602	// emitted destructur for type u64

		@@ -62991,10 +63603,10 @@
62991	63603	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 21
62992	63604	heap.availilable_size_for_dynamic_objects += 0LLU;
62993	63605	heap.availilable_size_for_dynamic_objects += 0LLU;
62994		- state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
	63606	+ state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
62995	63607	break;
62996	63608	}
62997		- case 18446744073709547888LLU: // 99999999Eu'''''''''''''''
	63609	+ case 18446744073709547848LLU: // 99999999EH'''''''''''''''
62998	63610	{
62999	63611	// ACCUMULATE ARGUMENTS - BEGIN
63000	63612	{

		@@ -63002,7 +63614,7 @@
63002	63614	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63003	63615	}
63004	63616	// ACCUMULATE ARGUMENTS - END
63005		- uint64_t return_to = 18446744073709547873LLU;
	63617	+ uint64_t return_to = 18446744073709547833LLU;
63006	63618	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63007	63619	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63008	63620	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63011,12 +63623,12 @@
63011	63623	state.addr = 839519719621918720LLU; // skipws____
63012	63624	break;
63013	63625	}
63014		- case 18446744073709547873LLU: // 99999999Ef'''''''''''''''
	63626	+ case 18446744073709547833LLU: // 99999999D3'''''''''''''''
63015	63627	{
63016		- state.addr = 18446744073709547874LLU; // 99999999Eg'''''''''''''''
	63628	+ state.addr = 18446744073709547834LLU; // 99999999D4'''''''''''''''
63017	63629	break;
63018	63630	}
63019		- case 18446744073709547874LLU: // 99999999Eg'''''''''''''''
	63631	+ case 18446744073709547834LLU: // 99999999D4'''''''''''''''
63020	63632	{
63021	63633	{
63022	63634	uint64_t arg = 0;

		@@ -63032,7 +63644,7 @@
63032	63644	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63033	63645	}
63034	63646	// ACCUMULATE ARGUMENTS - END
63035		- uint64_t return_to = 18446744073709547869LLU;
	63647	+ uint64_t return_to = 18446744073709547829LLU;
63036	63648	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
63037	63649	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63038	63650	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63041,22 +63653,22 @@
63041	63653	state.addr = 661605045736570880LLU; // isdigit___
63042	63654	break;
63043	63655	}
63044		- case 18446744073709547869LLU: // 99999999Eb'''''''''''''''
	63656	+ case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
63045	63657	{
63046		- state.addr = 18446744073709547870LLU; // 99999999Ec'''''''''''''''
	63658	+ state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
63047	63659	break;
63048	63660	}
63049		- case 18446744073709547870LLU: // 99999999Ec'''''''''''''''
	63661	+ case 18446744073709547830LLU: // 99999999D0'''''''''''''''
63050	63662	{
63051		- state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547872LLU : 18446744073709547871LLU;
	63663	+ state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709547832LLU : 18446744073709547831LLU;
63052	63664	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 21
63053	63665	break;
63054	63666	}
63055		- case 18446744073709547872LLU: // 99999999Ee'''''''''''''''
	63667	+ case 18446744073709547832LLU: // 99999999D2'''''''''''''''
63056	63668	{
63057	63669	// ACCUMULATE ARGUMENTS - BEGIN
63058	63670	// ACCUMULATE ARGUMENTS - END
63059		- uint64_t return_to = 18446744073709547867LLU;
	63671	+ uint64_t return_to = 18446744073709547827LLU;
63060	63672	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
63061	63673	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63062	63674	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63065,12 +63677,12 @@
63065	63677	state.addr = 890787671342055424LLU; // varopen___
63066	63678	break;
63067	63679	}
63068		- case 18446744073709547867LLU: // 99999999E$'''''''''''''''
	63680	+ case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
63069	63681	{
63070		- state.addr = 18446744073709547868LLU; // 99999999Ea'''''''''''''''
	63682	+ state.addr = 18446744073709547828LLU; // 99999999Dy'''''''''''''''
63071	63683	break;
63072	63684	}
63073		- case 18446744073709547868LLU: // 99999999Ea'''''''''''''''
	63685	+ case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
63074	63686	{
63075	63687	/buf_______/LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = parsenr(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)));
63076	63688	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -63079,7 +63691,7 @@
63079	63691	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63080	63692	}
63081	63693	// ACCUMULATE ARGUMENTS - END
63082		- uint64_t return_to = 18446744073709547865LLU;
	63694	+ uint64_t return_to = 18446744073709547825LLU;
63083	63695	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63084	63696	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63085	63697	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63088,17 +63700,17 @@
63088	63700	state.addr = 787446708198178816LLU; // printnr___
63089	63701	break;
63090	63702	}
63091		- case 18446744073709547865LLU: // 99999999EY'''''''''''''''
	63703	+ case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
63092	63704	{
63093		- state.addr = 18446744073709547866LLU; // 99999999EZ'''''''''''''''
	63705	+ state.addr = 18446744073709547826LLU; // 99999999Dw'''''''''''''''
63094	63706	break;
63095	63707	}
63096		- case 18446744073709547866LLU: // 99999999EZ'''''''''''''''
	63708	+ case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
63097	63709	{
63098		- state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547864LLU : 18446744073709547863LLU;
	63710	+ state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709547824LLU : 18446744073709547823LLU;
63099	63711	break;
63100	63712	}
63101		- case 18446744073709547864LLU: // 99999999EX'''''''''''''''
	63713	+ case 18446744073709547824LLU: // 99999999Du'''''''''''''''
63102	63714	{
63103	63715	// ACCUMULATE ARGUMENTS - BEGIN
63104	63716	{

		@@ -63110,7 +63722,7 @@
63110	63722	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63111	63723	}
63112	63724	// ACCUMULATE ARGUMENTS - END
63113		- uint64_t return_to = 18446744073709547861LLU;
	63725	+ uint64_t return_to = 18446744073709547821LLU;
63114	63726	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
63115	63727	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63116	63728	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63119,17 +63731,17 @@
63119	63731	state.addr = 517555565476695680LLU; // assertu64_
63120	63732	break;
63121	63733	}
63122		- case 18446744073709547861LLU: // 99999999EU'''''''''''''''
	63734	+ case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
63123	63735	{
63124		- state.addr = 18446744073709547862LLU; // 99999999EV'''''''''''''''
	63736	+ state.addr = 18446744073709547822LLU; // 99999999Ds'''''''''''''''
63125	63737	break;
63126	63738	}
63127		- case 18446744073709547862LLU: // 99999999EV'''''''''''''''
	63739	+ case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
63128	63740	{
63129		- state.addr = 18446744073709547863LLU; // 99999999EW'''''''''''''''
	63741	+ state.addr = 18446744073709547823LLU; // 99999999Dt'''''''''''''''
63130	63742	break;
63131	63743	}
63132		- case 18446744073709547863LLU: // 99999999EW'''''''''''''''
	63744	+ case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
63133	63745	{
63134	63746	{
63135	63747	uint64_t arg = 0LLU;

		@@ -63157,7 +63769,7 @@
63157	63769	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63158	63770	}
63159	63771	// ACCUMULATE ARGUMENTS - END
63160		- uint64_t return_to = 18446744073709547859LLU;
	63772	+ uint64_t return_to = 18446744073709547819LLU;
63161	63773	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
63162	63774	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63163	63775	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63166,12 +63778,12 @@
63166	63778	state.addr = 890786842582581248LLU; // varclose__
63167	63779	break;
63168	63780	}
63169		- case 18446744073709547859LLU: // 99999999ES'''''''''''''''
	63781	+ case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
63170	63782	{
63171		- state.addr = 18446744073709547860LLU; // 99999999ET'''''''''''''''
	63783	+ state.addr = 18446744073709547820LLU; // 99999999Dq'''''''''''''''
63172	63784	break;
63173	63785	}
63174		- case 18446744073709547860LLU: // 99999999ET'''''''''''''''
	63786	+ case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
63175	63787	{
63176	63788	{
63177	63789	uint64_t arg = 0LLU;

		@@ -63191,7 +63803,7 @@
63191	63803	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63192	63804	}
63193	63805	// ACCUMULATE ARGUMENTS - END
63194		- uint64_t return_to = 18446744073709547856LLU;
	63806	+ uint64_t return_to = 18446744073709547816LLU;
63195	63807	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
63196	63808	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63197	63809	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63200,12 +63812,12 @@
63200	63812	state.addr = 661658442972266496LLU; // isprim____
63201	63813	break;
63202	63814	}
63203		- case 18446744073709547856LLU: // 99999999EP'''''''''''''''
	63815	+ case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
63204	63816	{
63205		- state.addr = 18446744073709547857LLU; // 99999999EQ'''''''''''''''
	63817	+ state.addr = 18446744073709547817LLU; // 99999999Dn'''''''''''''''
63206	63818	break;
63207	63819	}
63208		- case 18446744073709547857LLU: // 99999999EQ'''''''''''''''
	63820	+ case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
63209	63821	{
63210	63822	{
63211	63823	uint64_t arg = 0;

		@@ -63221,7 +63833,7 @@
63221	63833	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63222	63834	}
63223	63835	// ACCUMULATE ARGUMENTS - END
63224		- uint64_t return_to = 18446744073709547854LLU;
	63836	+ uint64_t return_to = 18446744073709547814LLU;
63225	63837	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
63226	63838	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63227	63839	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63230,12 +63842,12 @@
63230	63842	state.addr = 367395560426147840LLU; // TYPECOPY__
63231	63843	break;
63232	63844	}
63233		- case 18446744073709547854LLU: // 99999999EN'''''''''''''''
	63845	+ case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
63234	63846	{
63235		- state.addr = 18446744073709547855LLU; // 99999999EO'''''''''''''''
	63847	+ state.addr = 18446744073709547815LLU; // 99999999Dl'''''''''''''''
63236	63848	break;
63237	63849	}
63238		- case 18446744073709547855LLU: // 99999999EO'''''''''''''''
	63850	+ case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
63239	63851	{
63240	63852	// ACCUMULATE ARGUMENTS - BEGIN
63241	63853	{

		@@ -63267,7 +63879,7 @@
63267	63879	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63268	63880	}
63269	63881	// ACCUMULATE ARGUMENTS - END
63270		- uint64_t return_to = 18446744073709547852LLU;
	63882	+ uint64_t return_to = 18446744073709547812LLU;
63271	63883	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
63272	63884	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63273	63885	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63276,12 +63888,12 @@
63276	63888	state.addr = 788334703205941248LLU; // pushvar___
63277	63889	break;
63278	63890	}
63279		- case 18446744073709547852LLU: // 99999999EL'''''''''''''''
	63891	+ case 18446744073709547812LLU: // 99999999Di'''''''''''''''
63280	63892	{
63281		- state.addr = 18446744073709547853LLU; // 99999999EM'''''''''''''''
	63893	+ state.addr = 18446744073709547813LLU; // 99999999Dj'''''''''''''''
63282	63894	break;
63283	63895	}
63284		- case 18446744073709547853LLU: // 99999999EM'''''''''''''''
	63896	+ case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
63285	63897	{
63286	63898	// variable type______ t_________ goes out of scope
63287	63899	// emitted destructur for type type______

		@@ -63291,7 +63903,7 @@
63291	63903	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63292	63904	}
63293	63905	// ACCUMULATE ARGUMENTS - END
63294		- uint64_t return_to = 18446744073709547851LLU;
	63906	+ uint64_t return_to = 18446744073709547811LLU;
63295	63907	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63296	63908	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63297	63909	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63300,7 +63912,7 @@
63300	63912	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
63301	63913	break;
63302	63914	}
63303		- case 18446744073709547851LLU: // 99999999EK'''''''''''''''
	63915	+ case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
63304	63916	{
63305	63917	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 24
63306	63918	// variable u64 initialize goes out of scope

		@@ -63309,10 +63921,10 @@
63309	63921	// variable u64 INDIRECT__ goes out of scope
63310	63922	// emitted destructur for type u64
63311	63923	(void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 22
63312		- state.addr = 18446744073709547858LLU; // 99999999ER'''''''''''''''
	63924	+ state.addr = 18446744073709547818LLU; // 99999999Do'''''''''''''''
63313	63925	break;
63314	63926	}
63315		- case 18446744073709547858LLU: // 99999999ER'''''''''''''''
	63927	+ case 18446744073709547818LLU: // 99999999Do'''''''''''''''
63316	63928	{
63317	63929	// variable u64 varidx____ goes out of scope
63318	63930	// emitted destructur for type u64

		@@ -63319,10 +63931,10 @@
63319	63931	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 21
63320	63932	heap.availilable_size_for_dynamic_objects += 0LLU;
63321	63933	heap.availilable_size_for_dynamic_objects += 0LLU;
63322		- state.addr = 18446744073709547850LLU; // 99999999EJ'''''''''''''''
	63934	+ state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
63323	63935	break;
63324	63936	}
63325		- case 18446744073709547871LLU: // 99999999Ed'''''''''''''''
	63937	+ case 18446744073709547831LLU: // 99999999D1'''''''''''''''
63326	63938	{
63327	63939	{
63328	63940	uint64_t arg = 0LLU;

		@@ -63338,7 +63950,7 @@
63338	63950	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63339	63951	}
63340	63952	// ACCUMULATE ARGUMENTS - END
63341		- uint64_t return_to = 18446744073709547848LLU;
	63953	+ uint64_t return_to = 18446744073709547808LLU;
63342	63954	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63343	63955	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63344	63956	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63347,12 +63959,12 @@
63347	63959	state.addr = 839519719621918720LLU; // skipws____
63348	63960	break;
63349	63961	}
63350		- case 18446744073709547848LLU: // 99999999EH'''''''''''''''
	63962	+ case 18446744073709547808LLU: // 99999999De'''''''''''''''
63351	63963	{
63352		- state.addr = 18446744073709547849LLU; // 99999999EI'''''''''''''''
	63964	+ state.addr = 18446744073709547809LLU; // 99999999Df'''''''''''''''
63353	63965	break;
63354	63966	}
63355		- case 18446744073709547849LLU: // 99999999EI'''''''''''''''
	63967	+ case 18446744073709547809LLU: // 99999999Df'''''''''''''''
63356	63968	{
63357	63969	/argid_____/LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 10LLU)));
63358	63970	{

		@@ -63381,7 +63993,7 @@
63381	63993	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63382	63994	}
63383	63995	// ACCUMULATE ARGUMENTS - END
63384		- uint64_t return_to = 18446744073709547846LLU;
	63996	+ uint64_t return_to = 18446744073709547806LLU;
63385	63997	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
63386	63998	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63387	63999	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63390,17 +64002,17 @@
63390	64002	state.addr = 750629765416882176LLU; // novarref__
63391	64003	break;
63392	64004	}
63393		- case 18446744073709547846LLU: // 99999999EF'''''''''''''''
	64005	+ case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
63394	64006	{
63395		- state.addr = 18446744073709547847LLU; // 99999999EG'''''''''''''''
	64007	+ state.addr = 18446744073709547807LLU; // 99999999Dd'''''''''''''''
63396	64008	break;
63397	64009	}
63398		- case 18446744073709547847LLU: // 99999999EG'''''''''''''''
	64010	+ case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
63399	64011	{
63400		- state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547845LLU : 18446744073709547844LLU;
	64012	+ state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709547805LLU : 18446744073709547804LLU;
63401	64013	break;
63402	64014	}
63403		- case 18446744073709547845LLU: // 99999999EE'''''''''''''''
	64015	+ case 18446744073709547805LLU: // 99999999Db'''''''''''''''
63404	64016	{
63405	64017	{
63406	64018	uint64_t arg = 0LLU;

		@@ -63412,7 +64024,7 @@
63412	64024	}
63413	64025	// ACCUMULATE ARGUMENTS - BEGIN
63414	64026	// ACCUMULATE ARGUMENTS - END
63415		- uint64_t return_to = 18446744073709547840LLU;
	64027	+ uint64_t return_to = 18446744073709547800LLU;
63416	64028	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
63417	64029	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63418	64030	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63421,12 +64033,12 @@
63421	64033	state.addr = 890787671342055424LLU; // varopen___
63422	64034	break;
63423	64035	}
63424		- case 18446744073709547840LLU: // 99999999E_'''''''''''''''
	64036	+ case 18446744073709547800LLU: // 99999999DX'''''''''''''''
63425	64037	{
63426		- state.addr = 18446744073709547841LLU; // 99999999EA'''''''''''''''
	64038	+ state.addr = 18446744073709547801LLU; // 99999999DY'''''''''''''''
63427	64039	break;
63428	64040	}
63429		- case 18446744073709547841LLU: // 99999999EA'''''''''''''''
	64041	+ case 18446744073709547801LLU: // 99999999DY'''''''''''''''
63430	64042	{
63431	64043	fprintf(stdout, "%s", "0");
63432	64044	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -63451,7 +64063,7 @@
63451	64063	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63452	64064	}
63453	64065	// ACCUMULATE ARGUMENTS - END
63454		- uint64_t return_to = 18446744073709547838LLU;
	64066	+ uint64_t return_to = 18446744073709547798LLU;
63455	64067	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
63456	64068	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63457	64069	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63460,12 +64072,12 @@
63460	64072	state.addr = 890786842582581248LLU; // varclose__
63461	64073	break;
63462	64074	}
63463		- case 18446744073709547838LLU: // 99999999D8'''''''''''''''
	64075	+ case 18446744073709547798LLU: // 99999999DV'''''''''''''''
63464	64076	{
63465		- state.addr = 18446744073709547839LLU; // 99999999D9'''''''''''''''
	64077	+ state.addr = 18446744073709547799LLU; // 99999999DW'''''''''''''''
63466	64078	break;
63467	64079	}
63468		- case 18446744073709547839LLU: // 99999999D9'''''''''''''''
	64080	+ case 18446744073709547799LLU: // 99999999DW'''''''''''''''
63469	64081	{
63470	64082	{
63471	64083	uint64_t arg = 0LLU;

		@@ -63489,7 +64101,7 @@
63489	64101	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63490	64102	}
63491	64103	// ACCUMULATE ARGUMENTS - END
63492		- uint64_t return_to = 18446744073709547836LLU;
	64104	+ uint64_t return_to = 18446744073709547796LLU;
63493	64105	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
63494	64106	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63495	64107	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63498,12 +64110,12 @@
63498	64110	state.addr = 768289076452424640LLU; // oneresult_
63499	64111	break;
63500	64112	}
63501		- case 18446744073709547836LLU: // 99999999D6'''''''''''''''
	64113	+ case 18446744073709547796LLU: // 99999999DT'''''''''''''''
63502	64114	{
63503		- state.addr = 18446744073709547837LLU; // 99999999D7'''''''''''''''
	64115	+ state.addr = 18446744073709547797LLU; // 99999999DU'''''''''''''''
63504	64116	break;
63505	64117	}
63506		- case 18446744073709547837LLU: // 99999999D7'''''''''''''''
	64118	+ case 18446744073709547797LLU: // 99999999DU'''''''''''''''
63507	64119	{
63508	64120	// ACCUMULATE ARGUMENTS - BEGIN
63509	64121	{

		@@ -63575,7 +64187,7 @@
63575	64187	LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63576	64188	}
63577	64189	// ACCUMULATE ARGUMENTS - END
63578		- uint64_t return_to = 18446744073709547834LLU;
	64190	+ uint64_t return_to = 18446744073709547794LLU;
63579	64191	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0));
63580	64192	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63581	64193	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63584,23 +64196,23 @@
63584	64196	state.addr = 782701543315110336LLU; // parsecall_
63585	64197	break;
63586	64198	}
63587		- case 18446744073709547834LLU: // 99999999D4'''''''''''''''
	64199	+ case 18446744073709547794LLU: // 99999999DR'''''''''''''''
63588	64200	{
63589		- state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
	64201	+ state.addr = 18446744073709547795LLU; // 99999999DS'''''''''''''''
63590	64202	break;
63591	64203	}
63592		- case 18446744073709547835LLU: // 99999999D5'''''''''''''''
	64204	+ case 18446744073709547795LLU: // 99999999DS'''''''''''''''
63593	64205	{
63594	64206	// variable list<resdest___> newresults goes out of scope
63595	64207	// emitted destructur for type list<resdest___>
63596		- state.addr = 18446744073709547832LLU; // 99999999D2'''''''''''''''
	64208	+ state.addr = 18446744073709547792LLU; // 99999999DP'''''''''''''''
63597	64209	break;
63598	64210	}
63599		- case 18446744073709547832LLU: // 99999999D2'''''''''''''''
	64211	+ case 18446744073709547792LLU: // 99999999DP'''''''''''''''
63600	64212	{
63601	64213	if(!LOCAL_ACCESS(heap.data, 26LLU, 25LLU)/list*/)
63602	64214	{
63603		- state.addr = 18446744073709547833LLU; // 99999999D3'''''''''''''''
	64215	+ state.addr = 18446744073709547793LLU; // 99999999DQ'''''''''''''''
63604	64216	break;
63605	64217	}
63606	64218	// temporary list-element

		@@ -63614,7 +64226,7 @@
63614	64226	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63615	64227	}
63616	64228	// ACCUMULATE ARGUMENTS - END
63617		- uint64_t return_to = 18446744073709547831LLU;
	64229	+ uint64_t return_to = 18446744073709547791LLU;
63618	64230	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63619	64231	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63620	64232	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63623,20 +64235,20 @@
63623	64235	state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
63624	64236	break;
63625	64237	}
63626		- case 18446744073709547831LLU: // 99999999D1'''''''''''''''
	64238	+ case 18446744073709547791LLU: // 99999999DO'''''''''''''''
63627	64239	{
63628	64240	// RELEASE temporary destructor-variable
63629	64241	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 27
63630		- state.addr = 18446744073709547832LLU; // 99999999D2'''''''''''''''
	64242	+ state.addr = 18446744073709547792LLU; // 99999999DP'''''''''''''''
63631	64243	break;
63632	64244	}
63633		- case 18446744073709547833LLU: // 99999999D3'''''''''''''''
	64245	+ case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
63634	64246	{
63635	64247	(void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference newresults at 26
63636		- state.addr = 18446744073709547842LLU; // 99999999EB'''''''''''''''
	64248	+ state.addr = 18446744073709547802LLU; // 99999999DZ'''''''''''''''
63637	64249	break;
63638	64250	}
63639		- case 18446744073709547842LLU: // 99999999EB'''''''''''''''
	64251	+ case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
63640	64252	{
63641	64253	{
63642	64254	uint64_t arg = 1LLU;

		@@ -63672,7 +64284,7 @@
63672	64284	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63673	64285	}
63674	64286	// ACCUMULATE ARGUMENTS - END
63675		- uint64_t return_to = 18446744073709547829LLU;
	64287	+ uint64_t return_to = 18446744073709547789LLU;
63676	64288	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
63677	64289	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63678	64290	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63681,12 +64293,12 @@
63681	64293	state.addr = 788334703205941248LLU; // pushvar___
63682	64294	break;
63683	64295	}
63684		- case 18446744073709547829LLU: // 99999999Dz'''''''''''''''
	64296	+ case 18446744073709547789LLU: // 99999999DM'''''''''''''''
63685	64297	{
63686		- state.addr = 18446744073709547830LLU; // 99999999D0'''''''''''''''
	64298	+ state.addr = 18446744073709547790LLU; // 99999999DN'''''''''''''''
63687	64299	break;
63688	64300	}
63689		- case 18446744073709547830LLU: // 99999999D0'''''''''''''''
	64301	+ case 18446744073709547790LLU: // 99999999DN'''''''''''''''
63690	64302	{
63691	64303	// variable u64 initialize goes out of scope
63692	64304	// emitted destructur for type u64

		@@ -63697,17 +64309,17 @@
63697	64309	// variable u64 varidx____ goes out of scope
63698	64310	// emitted destructur for type u64
63699	64311	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 24
63700		- state.addr = 18446744073709547843LLU; // 99999999EC'''''''''''''''
	64312	+ state.addr = 18446744073709547803LLU; // 99999999D$'''''''''''''''
63701	64313	break;
63702	64314	}
63703		- case 18446744073709547843LLU: // 99999999EC'''''''''''''''
	64315	+ case 18446744073709547803LLU: // 99999999D$'''''''''''''''
63704	64316	{
63705	64317	heap.availilable_size_for_dynamic_objects += 0LLU;
63706	64318	heap.availilable_size_for_dynamic_objects += 0LLU;
63707		- state.addr = 18446744073709547828LLU; // 99999999Dy'''''''''''''''
	64319	+ state.addr = 18446744073709547788LLU; // 99999999DL'''''''''''''''
63708	64320	break;
63709	64321	}
63710		- case 18446744073709547844LLU: // 99999999ED'''''''''''''''
	64322	+ case 18446744073709547804LLU: // 99999999Da'''''''''''''''
63711	64323	{
63712	64324	{
63713	64325	uint64_t arg = 0LLU;

		@@ -63715,7 +64327,7 @@
63715	64327	}
63716	64328	// ACCUMULATE ARGUMENTS - BEGIN
63717	64329	// ACCUMULATE ARGUMENTS - END
63718		- uint64_t return_to = 18446744073709547826LLU;
	64330	+ uint64_t return_to = 18446744073709547786LLU;
63719	64331	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0));
63720	64332	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63721	64333	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63724,12 +64336,12 @@
63724	64336	state.addr = 890787671342055424LLU; // varopen___
63725	64337	break;
63726	64338	}
63727		- case 18446744073709547826LLU: // 99999999Dw'''''''''''''''
	64339	+ case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
63728	64340	{
63729		- state.addr = 18446744073709547827LLU; // 99999999Dx'''''''''''''''
	64341	+ state.addr = 18446744073709547787LLU; // 99999999DK'''''''''''''''
63730	64342	break;
63731	64343	}
63732		- case 18446744073709547827LLU: // 99999999Dx'''''''''''''''
	64344	+ case 18446744073709547787LLU: // 99999999DK'''''''''''''''
63733	64345	{
63734	64346	{
63735	64347	uint64_t arg = 0;

		@@ -63741,7 +64353,7 @@
63741	64353	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63742	64354	}
63743	64355	// ACCUMULATE ARGUMENTS - END
63744		- uint64_t return_to = 18446744073709547823LLU;
	64356	+ uint64_t return_to = 18446744073709547783LLU;
63745	64357	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63746	64358	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63747	64359	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63750,12 +64362,12 @@
63750	64362	state.addr = 861504796319285248LLU; // typeu64___
63751	64363	break;
63752	64364	}
63753		- case 18446744073709547823LLU: // 99999999Dt'''''''''''''''
	64365	+ case 18446744073709547783LLU: // 99999999DG'''''''''''''''
63754	64366	{
63755		- state.addr = 18446744073709547824LLU; // 99999999Du'''''''''''''''
	64367	+ state.addr = 18446744073709547784LLU; // 99999999DH'''''''''''''''
63756	64368	break;
63757	64369	}
63758		- case 18446744073709547824LLU: // 99999999Du'''''''''''''''
	64370	+ case 18446744073709547784LLU: // 99999999DH'''''''''''''''
63759	64371	{
63760	64372	{
63761	64373	uint64_t arg = 0LLU;

		@@ -63835,7 +64447,7 @@
63835	64447	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63836	64448	}
63837	64449	// ACCUMULATE ARGUMENTS - END
63838		- uint64_t return_to = 18446744073709547821LLU;
	64450	+ uint64_t return_to = 18446744073709547781LLU;
63839	64451	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
63840	64452	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63841	64453	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63844,12 +64456,12 @@
63844	64456	state.addr = 787472342492567585LLU; // procvarref
63845	64457	break;
63846	64458	}
63847		- case 18446744073709547821LLU: // 99999999Dr'''''''''''''''
	64459	+ case 18446744073709547781LLU: // 99999999DE'''''''''''''''
63848	64460	{
63849		- state.addr = 18446744073709547822LLU; // 99999999Ds'''''''''''''''
	64461	+ state.addr = 18446744073709547782LLU; // 99999999DF'''''''''''''''
63850	64462	break;
63851	64463	}
63852		- case 18446744073709547822LLU: // 99999999Ds'''''''''''''''
	64464	+ case 18446744073709547782LLU: // 99999999DF'''''''''''''''
63853	64465	{
63854	64466	// ACCUMULATE ARGUMENTS - BEGIN
63855	64467	{

		@@ -63869,7 +64481,7 @@
63869	64481	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63870	64482	}
63871	64483	// ACCUMULATE ARGUMENTS - END
63872		- uint64_t return_to = 18446744073709547819LLU;
	64484	+ uint64_t return_to = 18446744073709547779LLU;
63873	64485	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
63874	64486	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63875	64487	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63878,12 +64490,12 @@
63878	64490	state.addr = 861504774606571689LLU; // typeassign
63879	64491	break;
63880	64492	}
63881		- case 18446744073709547819LLU: // 99999999Dp'''''''''''''''
	64493	+ case 18446744073709547779LLU: // 99999999DC'''''''''''''''
63882	64494	{
63883		- state.addr = 18446744073709547820LLU; // 99999999Dq'''''''''''''''
	64495	+ state.addr = 18446744073709547780LLU; // 99999999DD'''''''''''''''
63884	64496	break;
63885	64497	}
63886		- case 18446744073709547820LLU: // 99999999Dq'''''''''''''''
	64498	+ case 18446744073709547780LLU: // 99999999DD'''''''''''''''
63887	64499	{
63888	64500	// variable u64 initialize goes out of scope
63889	64501	// emitted destructur for type u64

		@@ -63905,7 +64517,7 @@
63905	64517	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63906	64518	}
63907	64519	// ACCUMULATE ARGUMENTS - END
63908		- uint64_t return_to = 18446744073709547818LLU;
	64520	+ uint64_t return_to = 18446744073709547778LLU;
63909	64521	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
63910	64522	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63911	64523	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63914,13 +64526,13 @@
63914	64526	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
63915	64527	break;
63916	64528	}
63917		- case 18446744073709547818LLU: // 99999999Do'''''''''''''''
	64529	+ case 18446744073709547778LLU: // 99999999DB'''''''''''''''
63918	64530	{
63919	64531	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typesrc___ at 25
63920		- state.addr = 18446744073709547825LLU; // 99999999Dv'''''''''''''''
	64532	+ state.addr = 18446744073709547785LLU; // 99999999DI'''''''''''''''
63921	64533	break;
63922	64534	}
63923		- case 18446744073709547825LLU: // 99999999Dv'''''''''''''''
	64535	+ case 18446744073709547785LLU: // 99999999DI'''''''''''''''
63924	64536	{
63925	64537	// ACCUMULATE ARGUMENTS - BEGIN
63926	64538	{

		@@ -63944,7 +64556,7 @@
63944	64556	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63945	64557	}
63946	64558	// ACCUMULATE ARGUMENTS - END
63947		- uint64_t return_to = 18446744073709547816LLU;
	64559	+ uint64_t return_to = 18446744073709547776LLU;
63948	64560	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
63949	64561	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63950	64562	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63953,12 +64565,12 @@
63953	64565	state.addr = 890786842582581248LLU; // varclose__
63954	64566	break;
63955	64567	}
63956		- case 18446744073709547816LLU: // 99999999Dm'''''''''''''''
	64568	+ case 18446744073709547776LLU: // 99999999D_'''''''''''''''
63957	64569	{
63958		- state.addr = 18446744073709547817LLU; // 99999999Dn'''''''''''''''
	64570	+ state.addr = 18446744073709547777LLU; // 99999999DA'''''''''''''''
63959	64571	break;
63960	64572	}
63961		- case 18446744073709547817LLU: // 99999999Dn'''''''''''''''
	64573	+ case 18446744073709547777LLU: // 99999999DA'''''''''''''''
63962	64574	{
63963	64575	{
63964	64576	uint64_t arg = 0LLU;

		@@ -63978,7 +64590,7 @@
63978	64590	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
63979	64591	}
63980	64592	// ACCUMULATE ARGUMENTS - END
63981		- uint64_t return_to = 18446744073709547813LLU;
	64593	+ uint64_t return_to = 18446744073709547773LLU;
63982	64594	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
63983	64595	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
63984	64596	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -63987,12 +64599,12 @@
63987	64599	state.addr = 661658442972266496LLU; // isprim____
63988	64600	break;
63989	64601	}
63990		- case 18446744073709547813LLU: // 99999999Dj'''''''''''''''
	64602	+ case 18446744073709547773LLU: // 99999999C7'''''''''''''''
63991	64603	{
63992		- state.addr = 18446744073709547814LLU; // 99999999Dk'''''''''''''''
	64604	+ state.addr = 18446744073709547774LLU; // 99999999C8'''''''''''''''
63993	64605	break;
63994	64606	}
63995		- case 18446744073709547814LLU: // 99999999Dk'''''''''''''''
	64607	+ case 18446744073709547774LLU: // 99999999C8'''''''''''''''
63996	64608	{
63997	64609	{
63998	64610	uint64_t arg = 0;

		@@ -64008,7 +64620,7 @@
64008	64620	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64009	64621	}
64010	64622	// ACCUMULATE ARGUMENTS - END
64011		- uint64_t return_to = 18446744073709547811LLU;
	64623	+ uint64_t return_to = 18446744073709547771LLU;
64012	64624	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
64013	64625	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64014	64626	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64017,12 +64629,12 @@
64017	64629	state.addr = 367395560426147840LLU; // TYPECOPY__
64018	64630	break;
64019	64631	}
64020		- case 18446744073709547811LLU: // 99999999Dh'''''''''''''''
	64632	+ case 18446744073709547771LLU: // 99999999C5'''''''''''''''
64021	64633	{
64022		- state.addr = 18446744073709547812LLU; // 99999999Di'''''''''''''''
	64634	+ state.addr = 18446744073709547772LLU; // 99999999C6'''''''''''''''
64023	64635	break;
64024	64636	}
64025		- case 18446744073709547812LLU: // 99999999Di'''''''''''''''
	64637	+ case 18446744073709547772LLU: // 99999999C6'''''''''''''''
64026	64638	{
64027	64639	// ACCUMULATE ARGUMENTS - BEGIN
64028	64640	{

		@@ -64054,7 +64666,7 @@
64054	64666	LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64055	64667	}
64056	64668	// ACCUMULATE ARGUMENTS - END
64057		- uint64_t return_to = 18446744073709547809LLU;
	64669	+ uint64_t return_to = 18446744073709547769LLU;
64058	64670	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0));
64059	64671	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64060	64672	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64063,12 +64675,12 @@
64063	64675	state.addr = 788334703205941248LLU; // pushvar___
64064	64676	break;
64065	64677	}
64066		- case 18446744073709547809LLU: // 99999999Df'''''''''''''''
	64678	+ case 18446744073709547769LLU: // 99999999C3'''''''''''''''
64067	64679	{
64068		- state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
	64680	+ state.addr = 18446744073709547770LLU; // 99999999C4'''''''''''''''
64069	64681	break;
64070	64682	}
64071		- case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
	64683	+ case 18446744073709547770LLU: // 99999999C4'''''''''''''''
64072	64684	{
64073	64685	// variable type______ t_________ goes out of scope
64074	64686	// emitted destructur for type type______

		@@ -64078,7 +64690,7 @@
64078	64690	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64079	64691	}
64080	64692	// ACCUMULATE ARGUMENTS - END
64081		- uint64_t return_to = 18446744073709547808LLU;
	64693	+ uint64_t return_to = 18446744073709547768LLU;
64082	64694	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64083	64695	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64084	64696	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64087,7 +64699,7 @@
64087	64699	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
64088	64700	break;
64089	64701	}
64090		- case 18446744073709547808LLU: // 99999999De'''''''''''''''
	64702	+ case 18446744073709547768LLU: // 99999999C2'''''''''''''''
64091	64703	{
64092	64704	(void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 27
64093	64705	// variable u64 initialize goes out of scope

		@@ -64096,18 +64708,18 @@
64096	64708	// variable u64 INDIRECT__ goes out of scope
64097	64709	// emitted destructur for type u64
64098	64710	(void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 25
64099		- state.addr = 18446744073709547815LLU; // 99999999Dl'''''''''''''''
	64711	+ state.addr = 18446744073709547775LLU; // 99999999C9'''''''''''''''
64100	64712	break;
64101	64713	}
64102		- case 18446744073709547815LLU: // 99999999Dl'''''''''''''''
	64714	+ case 18446744073709547775LLU: // 99999999C9'''''''''''''''
64103	64715	{
64104	64716	// variable u64 varidx____ goes out of scope
64105	64717	// emitted destructur for type u64
64106	64718	(void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 24
64107		- state.addr = 18446744073709547828LLU; // 99999999Dy'''''''''''''''
	64719	+ state.addr = 18446744073709547788LLU; // 99999999DL'''''''''''''''
64108	64720	break;
64109	64721	}
64110		- case 18446744073709547828LLU: // 99999999Dy'''''''''''''''
	64722	+ case 18446744073709547788LLU: // 99999999DL'''''''''''''''
64111	64723	{
64112	64724	// variable u64 notfound__ goes out of scope
64113	64725	// emitted destructur for type u64

		@@ -64118,23 +64730,23 @@
64118	64730	// variable u64 INDIRECT__ goes out of scope
64119	64731	// emitted destructur for type u64
64120	64732	(void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 21
64121		- state.addr = 18446744073709547850LLU; // 99999999EJ'''''''''''''''
	64733	+ state.addr = 18446744073709547810LLU; // 99999999Dg'''''''''''''''
64122	64734	break;
64123	64735	}
64124		- case 18446744073709547850LLU: // 99999999EJ'''''''''''''''
	64736	+ case 18446744073709547810LLU: // 99999999Dg'''''''''''''''
64125	64737	{
64126		- state.addr = 18446744073709547875LLU; // 99999999Eh'''''''''''''''
	64738	+ state.addr = 18446744073709547835LLU; // 99999999D5'''''''''''''''
64127	64739	break;
64128	64740	}
64129		- case 18446744073709547875LLU: // 99999999Eh'''''''''''''''
	64741	+ case 18446744073709547835LLU: // 99999999D5'''''''''''''''
64130	64742	{
64131	64743	// variable u64 buf_______ goes out of scope
64132	64744	// emitted destructur for type u64
64133	64745	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference buf_______ at 20
64134		- state.addr = 18446744073709547894LLU; // 99999999E0'''''''''''''''
	64746	+ state.addr = 18446744073709547854LLU; // 99999999EN'''''''''''''''
64135	64747	break;
64136	64748	}
64137		- case 18446744073709547894LLU: // 99999999E0'''''''''''''''
	64749	+ case 18446744073709547854LLU: // 99999999EN'''''''''''''''
64138	64750	{
64139	64751	// variable u64 redef_____ goes out of scope
64140	64752	// emitted destructur for type u64

		@@ -64147,7 +64759,7 @@
64147	64759	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64148	64760	}
64149	64761	// ACCUMULATE ARGUMENTS - END
64150		- uint64_t return_to = 18446744073709547807LLU;
	64762	+ uint64_t return_to = 18446744073709547767LLU;
64151	64763	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64152	64764	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64153	64765	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64156,7 +64768,7 @@
64156	64768	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
64157	64769	break;
64158	64770	}
64159		- case 18446744073709547807LLU: // 99999999Dd'''''''''''''''
	64771	+ case 18446744073709547767LLU: // 99999999C1'''''''''''''''
64160	64772	{
64161	64773	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedst___ at 18
64162	64774	// variable u64 mutable___ goes out of scope

		@@ -64212,10 +64824,10 @@
64212	64824	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 876383386118840320LLU;
64213	64825
64214	64826	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64215		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547806LLU : 18446744073709547805LLU;
	64827	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547766LLU : 18446744073709547765LLU;
64216	64828	break;
64217	64829	}
64218		- case 18446744073709547806LLU: // 99999999Dc'''''''''''''''
	64830	+ case 18446744073709547766LLU: // 99999999C0'''''''''''''''
64219	64831	{
64220	64832	// ACCUMULATE ARGUMENTS - BEGIN
64221	64833	{

		@@ -64223,7 +64835,7 @@
64223	64835	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64224	64836	}
64225	64837	// ACCUMULATE ARGUMENTS - END
64226		- uint64_t return_to = 18446744073709547803LLU;
	64838	+ uint64_t return_to = 18446744073709547763LLU;
64227	64839	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64228	64840	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64229	64841	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64232,12 +64844,12 @@
64232	64844	state.addr = 839519719621918720LLU; // skipws____
64233	64845	break;
64234	64846	}
64235		- case 18446744073709547803LLU: // 99999999D$'''''''''''''''
	64847	+ case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
64236	64848	{
64237		- state.addr = 18446744073709547804LLU; // 99999999Da'''''''''''''''
	64849	+ state.addr = 18446744073709547764LLU; // 99999999Cy'''''''''''''''
64238	64850	break;
64239	64851	}
64240		- case 18446744073709547804LLU: // 99999999Da'''''''''''''''
	64852	+ case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
64241	64853	{
64242	64854	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
64243	64855	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64246,7 +64858,7 @@
64246	64858	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64247	64859	}
64248	64860	// ACCUMULATE ARGUMENTS - END
64249		- uint64_t return_to = 18446744073709547801LLU;
	64861	+ uint64_t return_to = 18446744073709547761LLU;
64250	64862	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64251	64863	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64252	64864	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64255,12 +64867,12 @@
64255	64867	state.addr = 839519719621918720LLU; // skipws____
64256	64868	break;
64257	64869	}
64258		- case 18446744073709547801LLU: // 99999999DY'''''''''''''''
	64870	+ case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
64259	64871	{
64260		- state.addr = 18446744073709547802LLU; // 99999999DZ'''''''''''''''
	64872	+ state.addr = 18446744073709547762LLU; // 99999999Cw'''''''''''''''
64261	64873	break;
64262	64874	}
64263		- case 18446744073709547802LLU: // 99999999DZ'''''''''''''''
	64875	+ case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
64264	64876	{
64265	64877	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
64266	64878	if(')' != (char)getchar())

		@@ -64271,18 +64883,18 @@
64271	64883	fprintf(stdout, "%s", "\n ungetc(0, stdin);");
64272	64884	heap.availilable_size_for_dynamic_objects += 0LLU;
64273	64885	heap.availilable_size_for_dynamic_objects += 0LLU;
64274		- state.addr = 18446744073709547800LLU; // 99999999DX'''''''''''''''
	64886	+ state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
64275	64887	break;
64276	64888	}
64277		- case 18446744073709547805LLU: // 99999999Db'''''''''''''''
	64889	+ case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
64278	64890	{
64279	64891	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 605666980531466240LLU;
64280	64892
64281	64893	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64282		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547799LLU : 18446744073709547798LLU;
	64894	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547759LLU : 18446744073709547758LLU;
64283	64895	break;
64284	64896	}
64285		- case 18446744073709547799LLU: // 99999999DW'''''''''''''''
	64897	+ case 18446744073709547759LLU: // 99999999Ct'''''''''''''''
64286	64898	{
64287	64899	// ACCUMULATE ARGUMENTS - BEGIN
64288	64900	{

		@@ -64290,7 +64902,7 @@
64290	64902	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64291	64903	}
64292	64904	// ACCUMULATE ARGUMENTS - END
64293		- uint64_t return_to = 18446744073709547796LLU;
	64905	+ uint64_t return_to = 18446744073709547756LLU;
64294	64906	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64295	64907	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64296	64908	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64299,12 +64911,12 @@
64299	64911	state.addr = 839519719621918720LLU; // skipws____
64300	64912	break;
64301	64913	}
64302		- case 18446744073709547796LLU: // 99999999DT'''''''''''''''
	64914	+ case 18446744073709547756LLU: // 99999999Cq'''''''''''''''
64303	64915	{
64304		- state.addr = 18446744073709547797LLU; // 99999999DU'''''''''''''''
	64916	+ state.addr = 18446744073709547757LLU; // 99999999Cr'''''''''''''''
64305	64917	break;
64306	64918	}
64307		- case 18446744073709547797LLU: // 99999999DU'''''''''''''''
	64919	+ case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
64308	64920	{
64309	64921	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)));
64310	64922	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64313,7 +64925,7 @@
64313	64925	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64314	64926	}
64315	64927	// ACCUMULATE ARGUMENTS - END
64316		- uint64_t return_to = 18446744073709547794LLU;
	64928	+ uint64_t return_to = 18446744073709547754LLU;
64317	64929	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64318	64930	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64319	64931	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64322,12 +64934,12 @@
64322	64934	state.addr = 839519719621918720LLU; // skipws____
64323	64935	break;
64324	64936	}
64325		- case 18446744073709547794LLU: // 99999999DR'''''''''''''''
	64937	+ case 18446744073709547754LLU: // 99999999Co'''''''''''''''
64326	64938	{
64327		- state.addr = 18446744073709547795LLU; // 99999999DS'''''''''''''''
	64939	+ state.addr = 18446744073709547755LLU; // 99999999Cp'''''''''''''''
64328	64940	break;
64329	64941	}
64330		- case 18446744073709547795LLU: // 99999999DS'''''''''''''''
	64942	+ case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
64331	64943	{
64332	64944	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin);
64333	64945	if(')' != (char)getchar())

		@@ -64338,20 +64950,20 @@
64338	64950	fprintf(stdout, "%s", "\n fflush(stdout);");
64339	64951	heap.availilable_size_for_dynamic_objects += 0LLU;
64340	64952	heap.availilable_size_for_dynamic_objects += 0LLU;
64341		- state.addr = 18446744073709547793LLU; // 99999999DQ'''''''''''''''
	64953	+ state.addr = 18446744073709547753LLU; // 99999999Cn'''''''''''''''
64342	64954	break;
64343	64955	}
64344		- case 18446744073709547798LLU: // 99999999DV'''''''''''''''
	64956	+ case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
64345	64957	{
64346		- state.addr = 18446744073709547793LLU; // 99999999DQ'''''''''''''''
	64958	+ state.addr = 18446744073709547753LLU; // 99999999Cn'''''''''''''''
64347	64959	break;
64348	64960	}
64349		- case 18446744073709547793LLU: // 99999999DQ'''''''''''''''
	64961	+ case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
64350	64962	{
64351		- state.addr = 18446744073709547800LLU; // 99999999DX'''''''''''''''
	64963	+ state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
64352	64964	break;
64353	64965	}
64354		- case 18446744073709547800LLU: // 99999999DX'''''''''''''''
	64966	+ case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
64355	64967	{
64356	64968	// variable u64 sym_______ goes out of scope
64357	64969	// emitted destructur for type u64

		@@ -64401,10 +65013,10 @@
64401	65013	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183514351405LLU;
64402	65014
64403	65015	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64404		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547792LLU : 18446744073709547791LLU;
	65016	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547752LLU : 18446744073709547751LLU;
64405	65017	break;
64406	65018	}
64407		- case 18446744073709547792LLU: // 99999999DP'''''''''''''''
	65019	+ case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
64408	65020	{
64409	65021	{
64410	65022	uint64_t arg = 0LLU;

		@@ -64424,7 +65036,7 @@
64424	65036	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64425	65037	}
64426	65038	// ACCUMULATE ARGUMENTS - END
64427		- uint64_t return_to = 18446744073709547789LLU;
	65039	+ uint64_t return_to = 18446744073709547749LLU;
64428	65040	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64429	65041	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64430	65042	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64433,12 +65045,12 @@
64433	65045	state.addr = 861504796319285248LLU; // typeu64___
64434	65046	break;
64435	65047	}
64436		- case 18446744073709547789LLU: // 99999999DM'''''''''''''''
	65048	+ case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
64437	65049	{
64438		- state.addr = 18446744073709547790LLU; // 99999999DN'''''''''''''''
	65050	+ state.addr = 18446744073709547750LLU; // 99999999Ck'''''''''''''''
64439	65051	break;
64440	65052	}
64441		- case 18446744073709547790LLU: // 99999999DN'''''''''''''''
	65053	+ case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
64442	65054	{
64443	65055	// ACCUMULATE ARGUMENTS - BEGIN
64444	65056	{

		@@ -64446,7 +65058,7 @@
64446	65058	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64447	65059	}
64448	65060	// ACCUMULATE ARGUMENTS - END
64449		- uint64_t return_to = 18446744073709547787LLU;
	65061	+ uint64_t return_to = 18446744073709547747LLU;
64450	65062	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64451	65063	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64452	65064	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64455,12 +65067,12 @@
64455	65067	state.addr = 839519719621918720LLU; // skipws____
64456	65068	break;
64457	65069	}
64458		- case 18446744073709547787LLU: // 99999999DK'''''''''''''''
	65070	+ case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
64459	65071	{
64460		- state.addr = 18446744073709547788LLU; // 99999999DL'''''''''''''''
	65072	+ state.addr = 18446744073709547748LLU; // 99999999Ci'''''''''''''''
64461	65073	break;
64462	65074	}
64463		- case 18446744073709547788LLU: // 99999999DL'''''''''''''''
	65075	+ case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
64464	65076	{
64465	65077	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
64466	65078	fprintf(stdout, "%s", "\n putc((char)");

		@@ -64474,7 +65086,7 @@
64474	65086	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64475	65087	}
64476	65088	// ACCUMULATE ARGUMENTS - END
64477		- uint64_t return_to = 18446744073709547784LLU;
	65089	+ uint64_t return_to = 18446744073709547744LLU;
64478	65090	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64479	65091	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64480	65092	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64483,12 +65095,12 @@
64483	65095	state.addr = 839519719621918720LLU; // skipws____
64484	65096	break;
64485	65097	}
64486		- case 18446744073709547784LLU: // 99999999DH'''''''''''''''
	65098	+ case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
64487	65099	{
64488		- state.addr = 18446744073709547785LLU; // 99999999DI'''''''''''''''
	65100	+ state.addr = 18446744073709547745LLU; // 99999999Cf'''''''''''''''
64489	65101	break;
64490	65102	}
64491		- case 18446744073709547785LLU: // 99999999DI'''''''''''''''
	65103	+ case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
64492	65104	{
64493	65105	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
64494	65106	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64509,7 +65121,7 @@
64509	65121	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64510	65122	}
64511	65123	// ACCUMULATE ARGUMENTS - END
64512		- uint64_t return_to = 18446744073709547782LLU;
	65124	+ uint64_t return_to = 18446744073709547742LLU;
64513	65125	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
64514	65126	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64515	65127	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64518,12 +65130,12 @@
64518	65130	state.addr = 517555565473470767LLU; // assertinit
64519	65131	break;
64520	65132	}
64521		- case 18446744073709547782LLU: // 99999999DF'''''''''''''''
	65133	+ case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
64522	65134	{
64523		- state.addr = 18446744073709547783LLU; // 99999999DG'''''''''''''''
	65135	+ state.addr = 18446744073709547743LLU; // 99999999Cd'''''''''''''''
64524	65136	break;
64525	65137	}
64526		- case 18446744073709547783LLU: // 99999999DG'''''''''''''''
	65138	+ case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
64527	65139	{
64528	65140	{
64529	65141	uint64_t arg = 0LLU;

		@@ -64599,7 +65211,7 @@
64599	65211	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64600	65212	}
64601	65213	// ACCUMULATE ARGUMENTS - END
64602		- uint64_t return_to = 18446744073709547780LLU;
	65214	+ uint64_t return_to = 18446744073709547740LLU;
64603	65215	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
64604	65216	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64605	65217	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64608,12 +65220,12 @@
64608	65220	state.addr = 787472342492567585LLU; // procvarref
64609	65221	break;
64610	65222	}
64611		- case 18446744073709547780LLU: // 99999999DD'''''''''''''''
	65223	+ case 18446744073709547740LLU: // 99999999Ca'''''''''''''''
64612	65224	{
64613		- state.addr = 18446744073709547781LLU; // 99999999DE'''''''''''''''
	65225	+ state.addr = 18446744073709547741LLU; // 99999999Cb'''''''''''''''
64614	65226	break;
64615	65227	}
64616		- case 18446744073709547781LLU: // 99999999DE'''''''''''''''
	65228	+ case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
64617	65229	{
64618	65230	// variable u64 initialize goes out of scope
64619	65231	// emitted destructur for type u64

		@@ -64624,10 +65236,10 @@
64624	65236	// variable u64 idx_______ goes out of scope
64625	65237	// emitted destructur for type u64
64626	65238	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
64627		- state.addr = 18446744073709547786LLU; // 99999999DJ'''''''''''''''
	65239	+ state.addr = 18446744073709547746LLU; // 99999999Cg'''''''''''''''
64628	65240	break;
64629	65241	}
64630		- case 18446744073709547786LLU: // 99999999DJ'''''''''''''''
	65242	+ case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
64631	65243	{
64632	65244	fprintf(stdout, "%s", ", stderr);");
64633	65245	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64636,7 +65248,7 @@
64636	65248	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64637	65249	}
64638	65250	// ACCUMULATE ARGUMENTS - END
64639		- uint64_t return_to = 18446744073709547778LLU;
	65251	+ uint64_t return_to = 18446744073709547738LLU;
64640	65252	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64641	65253	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64642	65254	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64645,12 +65257,12 @@
64645	65257	state.addr = 839519719621918720LLU; // skipws____
64646	65258	break;
64647	65259	}
64648		- case 18446744073709547778LLU: // 99999999DB'''''''''''''''
	65260	+ case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
64649	65261	{
64650		- state.addr = 18446744073709547779LLU; // 99999999DC'''''''''''''''
	65262	+ state.addr = 18446744073709547739LLU; // 99999999C$'''''''''''''''
64651	65263	break;
64652	65264	}
64653		- case 18446744073709547779LLU: // 99999999DC'''''''''''''''
	65265	+ case 18446744073709547739LLU: // 99999999C$'''''''''''''''
64654	65266	{
64655	65267	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
64656	65268	if(')' != (char)getchar())

		@@ -64668,7 +65280,7 @@
64668	65280	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64669	65281	}
64670	65282	// ACCUMULATE ARGUMENTS - END
64671		- uint64_t return_to = 18446744073709547776LLU;
	65283	+ uint64_t return_to = 18446744073709547736LLU;
64672	65284	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
64673	65285	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64674	65286	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64677,12 +65289,12 @@
64677	65289	state.addr = 517555565476695680LLU; // assertu64_
64678	65290	break;
64679	65291	}
64680		- case 18446744073709547776LLU: // 99999999D_'''''''''''''''
	65292	+ case 18446744073709547736LLU: // 99999999CX'''''''''''''''
64681	65293	{
64682		- state.addr = 18446744073709547777LLU; // 99999999DA'''''''''''''''
	65294	+ state.addr = 18446744073709547737LLU; // 99999999CY'''''''''''''''
64683	65295	break;
64684	65296	}
64685		- case 18446744073709547777LLU: // 99999999DA'''''''''''''''
	65297	+ case 18446744073709547737LLU: // 99999999CY'''''''''''''''
64686	65298	{
64687	65299	// variable u64 mutable___ goes out of scope
64688	65300	// emitted destructur for type u64

		@@ -64695,7 +65307,7 @@
64695	65307	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64696	65308	}
64697	65309	// ACCUMULATE ARGUMENTS - END
64698		- uint64_t return_to = 18446744073709547775LLU;
	65310	+ uint64_t return_to = 18446744073709547735LLU;
64699	65311	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64700	65312	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64701	65313	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64704,7 +65316,7 @@
64704	65316	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
64705	65317	break;
64706	65318	}
64707		- case 18446744073709547775LLU: // 99999999C9'''''''''''''''
	65319	+ case 18446744073709547735LLU: // 99999999CW'''''''''''''''
64708	65320	{
64709	65321	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
64710	65322	// variable u64 INDIRECT__ goes out of scope

		@@ -64715,18 +65327,18 @@
64715	65327	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
64716	65328	heap.availilable_size_for_dynamic_objects += 0LLU;
64717	65329	heap.availilable_size_for_dynamic_objects += 0LLU;
64718		- state.addr = 18446744073709547774LLU; // 99999999C8'''''''''''''''
	65330	+ state.addr = 18446744073709547734LLU; // 99999999CV'''''''''''''''
64719	65331	break;
64720	65332	}
64721		- case 18446744073709547791LLU: // 99999999DO'''''''''''''''
	65333	+ case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
64722	65334	{
64723	65335	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708011125568LLU;
64724	65336
64725	65337	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
64726		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547773LLU : 18446744073709547772LLU;
	65338	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547733LLU : 18446744073709547732LLU;
64727	65339	break;
64728	65340	}
64729		- case 18446744073709547773LLU: // 99999999C7'''''''''''''''
	65341	+ case 18446744073709547733LLU: // 99999999CU'''''''''''''''
64730	65342	{
64731	65343	{
64732	65344	uint64_t arg = 0LLU;

		@@ -64746,7 +65358,7 @@
64746	65358	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64747	65359	}
64748	65360	// ACCUMULATE ARGUMENTS - END
64749		- uint64_t return_to = 18446744073709547770LLU;
	65361	+ uint64_t return_to = 18446744073709547730LLU;
64750	65362	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64751	65363	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64752	65364	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64755,12 +65367,12 @@
64755	65367	state.addr = 861504796319285248LLU; // typeu64___
64756	65368	break;
64757	65369	}
64758		- case 18446744073709547770LLU: // 99999999C4'''''''''''''''
	65370	+ case 18446744073709547730LLU: // 99999999CR'''''''''''''''
64759	65371	{
64760		- state.addr = 18446744073709547771LLU; // 99999999C5'''''''''''''''
	65372	+ state.addr = 18446744073709547731LLU; // 99999999CS'''''''''''''''
64761	65373	break;
64762	65374	}
64763		- case 18446744073709547771LLU: // 99999999C5'''''''''''''''
	65375	+ case 18446744073709547731LLU: // 99999999CS'''''''''''''''
64764	65376	{
64765	65377	// ACCUMULATE ARGUMENTS - BEGIN
64766	65378	{

		@@ -64768,7 +65380,7 @@
64768	65380	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64769	65381	}
64770	65382	// ACCUMULATE ARGUMENTS - END
64771		- uint64_t return_to = 18446744073709547768LLU;
	65383	+ uint64_t return_to = 18446744073709547728LLU;
64772	65384	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64773	65385	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64774	65386	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64777,12 +65389,12 @@
64777	65389	state.addr = 839519719621918720LLU; // skipws____
64778	65390	break;
64779	65391	}
64780		- case 18446744073709547768LLU: // 99999999C2'''''''''''''''
	65392	+ case 18446744073709547728LLU: // 99999999CP'''''''''''''''
64781	65393	{
64782		- state.addr = 18446744073709547769LLU; // 99999999C3'''''''''''''''
	65394	+ state.addr = 18446744073709547729LLU; // 99999999CQ'''''''''''''''
64783	65395	break;
64784	65396	}
64785		- case 18446744073709547769LLU: // 99999999C3'''''''''''''''
	65397	+ case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
64786	65398	{
64787	65399	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
64788	65400	fprintf(stdout, "%s", "\n putc((char)");

		@@ -64796,7 +65408,7 @@
64796	65408	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64797	65409	}
64798	65410	// ACCUMULATE ARGUMENTS - END
64799		- uint64_t return_to = 18446744073709547765LLU;
	65411	+ uint64_t return_to = 18446744073709547725LLU;
64800	65412	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64801	65413	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64802	65414	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64805,12 +65417,12 @@
64805	65417	state.addr = 839519719621918720LLU; // skipws____
64806	65418	break;
64807	65419	}
64808		- case 18446744073709547765LLU: // 99999999Cz'''''''''''''''
	65420	+ case 18446744073709547725LLU: // 99999999CM'''''''''''''''
64809	65421	{
64810		- state.addr = 18446744073709547766LLU; // 99999999C0'''''''''''''''
	65422	+ state.addr = 18446744073709547726LLU; // 99999999CN'''''''''''''''
64811	65423	break;
64812	65424	}
64813		- case 18446744073709547766LLU: // 99999999C0'''''''''''''''
	65425	+ case 18446744073709547726LLU: // 99999999CN'''''''''''''''
64814	65426	{
64815	65427	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
64816	65428	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64831,7 +65443,7 @@
64831	65443	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64832	65444	}
64833	65445	// ACCUMULATE ARGUMENTS - END
64834		- uint64_t return_to = 18446744073709547763LLU;
	65446	+ uint64_t return_to = 18446744073709547723LLU;
64835	65447	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
64836	65448	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64837	65449	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64840,12 +65452,12 @@
64840	65452	state.addr = 517555565473470767LLU; // assertinit
64841	65453	break;
64842	65454	}
64843		- case 18446744073709547763LLU: // 99999999Cx'''''''''''''''
	65455	+ case 18446744073709547723LLU: // 99999999CK'''''''''''''''
64844	65456	{
64845		- state.addr = 18446744073709547764LLU; // 99999999Cy'''''''''''''''
	65457	+ state.addr = 18446744073709547724LLU; // 99999999CL'''''''''''''''
64846	65458	break;
64847	65459	}
64848		- case 18446744073709547764LLU: // 99999999Cy'''''''''''''''
	65460	+ case 18446744073709547724LLU: // 99999999CL'''''''''''''''
64849	65461	{
64850	65462	{
64851	65463	uint64_t arg = 0LLU;

		@@ -64921,7 +65533,7 @@
64921	65533	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64922	65534	}
64923	65535	// ACCUMULATE ARGUMENTS - END
64924		- uint64_t return_to = 18446744073709547761LLU;
	65536	+ uint64_t return_to = 18446744073709547721LLU;
64925	65537	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
64926	65538	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64927	65539	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64930,12 +65542,12 @@
64930	65542	state.addr = 787472342492567585LLU; // procvarref
64931	65543	break;
64932	65544	}
64933		- case 18446744073709547761LLU: // 99999999Cv'''''''''''''''
	65545	+ case 18446744073709547721LLU: // 99999999CI'''''''''''''''
64934	65546	{
64935		- state.addr = 18446744073709547762LLU; // 99999999Cw'''''''''''''''
	65547	+ state.addr = 18446744073709547722LLU; // 99999999CJ'''''''''''''''
64936	65548	break;
64937	65549	}
64938		- case 18446744073709547762LLU: // 99999999Cw'''''''''''''''
	65550	+ case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
64939	65551	{
64940	65552	// variable u64 initialize goes out of scope
64941	65553	// emitted destructur for type u64

		@@ -64946,10 +65558,10 @@
64946	65558	// variable u64 idx_______ goes out of scope
64947	65559	// emitted destructur for type u64
64948	65560	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
64949		- state.addr = 18446744073709547767LLU; // 99999999C1'''''''''''''''
	65561	+ state.addr = 18446744073709547727LLU; // 99999999CO'''''''''''''''
64950	65562	break;
64951	65563	}
64952		- case 18446744073709547767LLU: // 99999999C1'''''''''''''''
	65564	+ case 18446744073709547727LLU: // 99999999CO'''''''''''''''
64953	65565	{
64954	65566	fprintf(stdout, "%s", ", stdout);");
64955	65567	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -64958,7 +65570,7 @@
64958	65570	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64959	65571	}
64960	65572	// ACCUMULATE ARGUMENTS - END
64961		- uint64_t return_to = 18446744073709547759LLU;
	65573	+ uint64_t return_to = 18446744073709547719LLU;
64962	65574	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
64963	65575	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64964	65576	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64967,12 +65579,12 @@
64967	65579	state.addr = 839519719621918720LLU; // skipws____
64968	65580	break;
64969	65581	}
64970		- case 18446744073709547759LLU: // 99999999Ct'''''''''''''''
	65582	+ case 18446744073709547719LLU: // 99999999CG'''''''''''''''
64971	65583	{
64972		- state.addr = 18446744073709547760LLU; // 99999999Cu'''''''''''''''
	65584	+ state.addr = 18446744073709547720LLU; // 99999999CH'''''''''''''''
64973	65585	break;
64974	65586	}
64975		- case 18446744073709547760LLU: // 99999999Cu'''''''''''''''
	65587	+ case 18446744073709547720LLU: // 99999999CH'''''''''''''''
64976	65588	{
64977	65589	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
64978	65590	if(')' != (char)getchar())

		@@ -64990,7 +65602,7 @@
64990	65602	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
64991	65603	}
64992	65604	// ACCUMULATE ARGUMENTS - END
64993		- uint64_t return_to = 18446744073709547757LLU;
	65605	+ uint64_t return_to = 18446744073709547717LLU;
64994	65606	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
64995	65607	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
64996	65608	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -64999,12 +65611,12 @@
64999	65611	state.addr = 517555565476695680LLU; // assertu64_
65000	65612	break;
65001	65613	}
65002		- case 18446744073709547757LLU: // 99999999Cr'''''''''''''''
	65614	+ case 18446744073709547717LLU: // 99999999CE'''''''''''''''
65003	65615	{
65004		- state.addr = 18446744073709547758LLU; // 99999999Cs'''''''''''''''
	65616	+ state.addr = 18446744073709547718LLU; // 99999999CF'''''''''''''''
65005	65617	break;
65006	65618	}
65007		- case 18446744073709547758LLU: // 99999999Cs'''''''''''''''
	65619	+ case 18446744073709547718LLU: // 99999999CF'''''''''''''''
65008	65620	{
65009	65621	// variable u64 mutable___ goes out of scope
65010	65622	// emitted destructur for type u64

		@@ -65017,7 +65629,7 @@
65017	65629	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65018	65630	}
65019	65631	// ACCUMULATE ARGUMENTS - END
65020		- uint64_t return_to = 18446744073709547756LLU;
	65632	+ uint64_t return_to = 18446744073709547716LLU;
65021	65633	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65022	65634	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65023	65635	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65026,7 +65638,7 @@
65026	65638	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
65027	65639	break;
65028	65640	}
65029		- case 18446744073709547756LLU: // 99999999Cq'''''''''''''''
	65641	+ case 18446744073709547716LLU: // 99999999CD'''''''''''''''
65030	65642	{
65031	65643	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
65032	65644	// variable u64 INDIRECT__ goes out of scope

		@@ -65037,18 +65649,18 @@
65037	65649	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
65038	65650	heap.availilable_size_for_dynamic_objects += 0LLU;
65039	65651	heap.availilable_size_for_dynamic_objects += 0LLU;
65040		- state.addr = 18446744073709547755LLU; // 99999999Cp'''''''''''''''
	65652	+ state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
65041	65653	break;
65042	65654	}
65043		- case 18446744073709547772LLU: // 99999999C6'''''''''''''''
	65655	+ case 18446744073709547732LLU: // 99999999CT'''''''''''''''
65044	65656	{
65045	65657	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 621705556409974784LLU;
65046	65658
65047	65659	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65048		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547754LLU : 18446744073709547753LLU;
	65660	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547714LLU : 18446744073709547713LLU;
65049	65661	break;
65050	65662	}
65051		- case 18446744073709547754LLU: // 99999999Co'''''''''''''''
	65663	+ case 18446744073709547714LLU: // 99999999CB'''''''''''''''
65052	65664	{
65053	65665	{
65054	65666	uint64_t arg = 0LLU;

		@@ -65068,7 +65680,7 @@
65068	65680	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65069	65681	}
65070	65682	// ACCUMULATE ARGUMENTS - END
65071		- uint64_t return_to = 18446744073709547751LLU;
	65683	+ uint64_t return_to = 18446744073709547711LLU;
65072	65684	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65073	65685	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65074	65686	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65077,12 +65689,12 @@
65077	65689	state.addr = 861504796319285248LLU; // typeu64___
65078	65690	break;
65079	65691	}
65080		- case 18446744073709547751LLU: // 99999999Cl'''''''''''''''
	65692	+ case 18446744073709547711LLU: // 99999999B9'''''''''''''''
65081	65693	{
65082		- state.addr = 18446744073709547752LLU; // 99999999Cm'''''''''''''''
	65694	+ state.addr = 18446744073709547712LLU; // 99999999C_'''''''''''''''
65083	65695	break;
65084	65696	}
65085		- case 18446744073709547752LLU: // 99999999Cm'''''''''''''''
	65697	+ case 18446744073709547712LLU: // 99999999C_'''''''''''''''
65086	65698	{
65087	65699	// ACCUMULATE ARGUMENTS - BEGIN
65088	65700	{

		@@ -65090,7 +65702,7 @@
65090	65702	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65091	65703	}
65092	65704	// ACCUMULATE ARGUMENTS - END
65093		- uint64_t return_to = 18446744073709547749LLU;
	65705	+ uint64_t return_to = 18446744073709547709LLU;
65094	65706	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65095	65707	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65096	65708	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65099,12 +65711,12 @@
65099	65711	state.addr = 839519719621918720LLU; // skipws____
65100	65712	break;
65101	65713	}
65102		- case 18446744073709547749LLU: // 99999999Cj'''''''''''''''
	65714	+ case 18446744073709547709LLU: // 99999999B7'''''''''''''''
65103	65715	{
65104		- state.addr = 18446744073709547750LLU; // 99999999Ck'''''''''''''''
	65716	+ state.addr = 18446744073709547710LLU; // 99999999B8'''''''''''''''
65105	65717	break;
65106	65718	}
65107		- case 18446744073709547750LLU: // 99999999Ck'''''''''''''''
	65719	+ case 18446744073709547710LLU: // 99999999B8'''''''''''''''
65108	65720	{
65109	65721	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
65110	65722	fprintf(stdout, "%s", "\n ");

		@@ -65118,7 +65730,7 @@
65118	65730	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65119	65731	}
65120	65732	// ACCUMULATE ARGUMENTS - END
65121		- uint64_t return_to = 18446744073709547746LLU;
	65733	+ uint64_t return_to = 18446744073709547706LLU;
65122	65734	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65123	65735	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65124	65736	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65127,12 +65739,12 @@
65127	65739	state.addr = 839519719621918720LLU; // skipws____
65128	65740	break;
65129	65741	}
65130		- case 18446744073709547746LLU: // 99999999Cg'''''''''''''''
	65742	+ case 18446744073709547706LLU: // 99999999B4'''''''''''''''
65131	65743	{
65132		- state.addr = 18446744073709547747LLU; // 99999999Ch'''''''''''''''
	65744	+ state.addr = 18446744073709547707LLU; // 99999999B5'''''''''''''''
65133	65745	break;
65134	65746	}
65135		- case 18446744073709547747LLU: // 99999999Ch'''''''''''''''
	65747	+ case 18446744073709547707LLU: // 99999999B5'''''''''''''''
65136	65748	{
65137	65749	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
65138	65750	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -65153,7 +65765,7 @@
65153	65765	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65154	65766	}
65155	65767	// ACCUMULATE ARGUMENTS - END
65156		- uint64_t return_to = 18446744073709547744LLU;
	65768	+ uint64_t return_to = 18446744073709547704LLU;
65157	65769	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
65158	65770	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65159	65771	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65162,12 +65774,12 @@
65162	65774	state.addr = 517555565473470767LLU; // assertinit
65163	65775	break;
65164	65776	}
65165		- case 18446744073709547744LLU: // 99999999Ce'''''''''''''''
	65777	+ case 18446744073709547704LLU: // 99999999B2'''''''''''''''
65166	65778	{
65167		- state.addr = 18446744073709547745LLU; // 99999999Cf'''''''''''''''
	65779	+ state.addr = 18446744073709547705LLU; // 99999999B3'''''''''''''''
65168	65780	break;
65169	65781	}
65170		- case 18446744073709547745LLU: // 99999999Cf'''''''''''''''
	65782	+ case 18446744073709547705LLU: // 99999999B3'''''''''''''''
65171	65783	{
65172	65784	{
65173	65785	uint64_t arg = 0LLU;

		@@ -65243,7 +65855,7 @@
65243	65855	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65244	65856	}
65245	65857	// ACCUMULATE ARGUMENTS - END
65246		- uint64_t return_to = 18446744073709547742LLU;
	65858	+ uint64_t return_to = 18446744073709547702LLU;
65247	65859	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
65248	65860	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65249	65861	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65252,12 +65864,12 @@
65252	65864	state.addr = 787472342492567585LLU; // procvarref
65253	65865	break;
65254	65866	}
65255		- case 18446744073709547742LLU: // 99999999Cc'''''''''''''''
	65867	+ case 18446744073709547702LLU: // 99999999B0'''''''''''''''
65256	65868	{
65257		- state.addr = 18446744073709547743LLU; // 99999999Cd'''''''''''''''
	65869	+ state.addr = 18446744073709547703LLU; // 99999999B1'''''''''''''''
65258	65870	break;
65259	65871	}
65260		- case 18446744073709547743LLU: // 99999999Cd'''''''''''''''
	65872	+ case 18446744073709547703LLU: // 99999999B1'''''''''''''''
65261	65873	{
65262	65874	// variable u64 initialize goes out of scope
65263	65875	// emitted destructur for type u64

		@@ -65268,10 +65880,10 @@
65268	65880	// variable u64 idx_______ goes out of scope
65269	65881	// emitted destructur for type u64
65270	65882	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
65271		- state.addr = 18446744073709547748LLU; // 99999999Ci'''''''''''''''
	65883	+ state.addr = 18446744073709547708LLU; // 99999999B6'''''''''''''''
65272	65884	break;
65273	65885	}
65274		- case 18446744073709547748LLU: // 99999999Ci'''''''''''''''
	65886	+ case 18446744073709547708LLU: // 99999999B6'''''''''''''''
65275	65887	{
65276	65888	fprintf(stdout, "%s", " = (uint64_t)getchar();");
65277	65889	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -65280,7 +65892,7 @@
65280	65892	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65281	65893	}
65282	65894	// ACCUMULATE ARGUMENTS - END
65283		- uint64_t return_to = 18446744073709547740LLU;
	65895	+ uint64_t return_to = 18446744073709547700LLU;
65284	65896	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65285	65897	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65286	65898	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65289,12 +65901,12 @@
65289	65901	state.addr = 839519719621918720LLU; // skipws____
65290	65902	break;
65291	65903	}
65292		- case 18446744073709547740LLU: // 99999999Ca'''''''''''''''
	65904	+ case 18446744073709547700LLU: // 99999999By'''''''''''''''
65293	65905	{
65294		- state.addr = 18446744073709547741LLU; // 99999999Cb'''''''''''''''
	65906	+ state.addr = 18446744073709547701LLU; // 99999999Bz'''''''''''''''
65295	65907	break;
65296	65908	}
65297		- case 18446744073709547741LLU: // 99999999Cb'''''''''''''''
	65909	+ case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
65298	65910	{
65299	65911	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
65300	65912	if(')' != (char)getchar())

		@@ -65312,7 +65924,7 @@
65312	65924	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65313	65925	}
65314	65926	// ACCUMULATE ARGUMENTS - END
65315		- uint64_t return_to = 18446744073709547738LLU;
	65927	+ uint64_t return_to = 18446744073709547698LLU;
65316	65928	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
65317	65929	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65318	65930	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65321,12 +65933,12 @@
65321	65933	state.addr = 517555565476695680LLU; // assertu64_
65322	65934	break;
65323	65935	}
65324		- case 18446744073709547738LLU: // 99999999CZ'''''''''''''''
	65936	+ case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
65325	65937	{
65326		- state.addr = 18446744073709547739LLU; // 99999999C$'''''''''''''''
	65938	+ state.addr = 18446744073709547699LLU; // 99999999Bx'''''''''''''''
65327	65939	break;
65328	65940	}
65329		- case 18446744073709547739LLU: // 99999999C$'''''''''''''''
	65941	+ case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
65330	65942	{
65331	65943	{
65332	65944	uint64_t arg = 1LLU;

		@@ -65354,7 +65966,7 @@
65354	65966	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65355	65967	}
65356	65968	// ACCUMULATE ARGUMENTS - END
65357		- uint64_t return_to = 18446744073709547735LLU;
	65969	+ uint64_t return_to = 18446744073709547695LLU;
65358	65970	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
65359	65971	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65360	65972	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65363,20 +65975,20 @@
65363	65975	state.addr = 734295421765213120LLU; // mutassert_
65364	65976	break;
65365	65977	}
65366		- case 18446744073709547735LLU: // 99999999CW'''''''''''''''
	65978	+ case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
65367	65979	{
65368		- state.addr = 18446744073709547736LLU; // 99999999CX'''''''''''''''
	65980	+ state.addr = 18446744073709547696LLU; // 99999999Bu'''''''''''''''
65369	65981	break;
65370	65982	}
65371		- case 18446744073709547736LLU: // 99999999CX'''''''''''''''
	65983	+ case 18446744073709547696LLU: // 99999999Bu'''''''''''''''
65372	65984	{
65373	65985	// variable u64 parnr_____ goes out of scope
65374	65986	// emitted destructur for type u64
65375	65987	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
65376		- state.addr = 18446744073709547737LLU; // 99999999CY'''''''''''''''
	65988	+ state.addr = 18446744073709547697LLU; // 99999999Bv'''''''''''''''
65377	65989	break;
65378	65990	}
65379		- case 18446744073709547737LLU: // 99999999CY'''''''''''''''
	65991	+ case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
65380	65992	{
65381	65993	// variable u64 mutable___ goes out of scope
65382	65994	// emitted destructur for type u64

		@@ -65389,7 +66001,7 @@
65389	66001	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65390	66002	}
65391	66003	// ACCUMULATE ARGUMENTS - END
65392		- uint64_t return_to = 18446744073709547734LLU;
	66004	+ uint64_t return_to = 18446744073709547694LLU;
65393	66005	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65394	66006	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65395	66007	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65398,7 +66010,7 @@
65398	66010	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
65399	66011	break;
65400	66012	}
65401		- case 18446744073709547734LLU: // 99999999CV'''''''''''''''
	66013	+ case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
65402	66014	{
65403	66015	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
65404	66016	// variable u64 INDIRECT__ goes out of scope

		@@ -65409,18 +66021,18 @@
65409	66021	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
65410	66022	heap.availilable_size_for_dynamic_objects += 0LLU;
65411	66023	heap.availilable_size_for_dynamic_objects += 0LLU;
65412		- state.addr = 18446744073709547733LLU; // 99999999CU'''''''''''''''
	66024	+ state.addr = 18446744073709547693LLU; // 99999999Br'''''''''''''''
65413	66025	break;
65414	66026	}
65415		- case 18446744073709547753LLU: // 99999999Cn'''''''''''''''
	66027	+ case 18446744073709547713LLU: // 99999999CA'''''''''''''''
65416	66028	{
65417	66029	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 783769716797919232LLU;
65418	66030
65419	66031	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65420		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547732LLU : 18446744073709547731LLU;
	66032	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547692LLU : 18446744073709547691LLU;
65421	66033	break;
65422	66034	}
65423		- case 18446744073709547732LLU: // 99999999CT'''''''''''''''
	66035	+ case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
65424	66036	{
65425	66037	{
65426	66038	uint64_t arg = 0LLU;

		@@ -65440,7 +66052,7 @@
65440	66052	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65441	66053	}
65442	66054	// ACCUMULATE ARGUMENTS - END
65443		- uint64_t return_to = 18446744073709547729LLU;
	66055	+ uint64_t return_to = 18446744073709547689LLU;
65444	66056	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65445	66057	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65446	66058	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65449,12 +66061,12 @@
65449	66061	state.addr = 861504796319285248LLU; // typeu64___
65450	66062	break;
65451	66063	}
65452		- case 18446744073709547729LLU: // 99999999CQ'''''''''''''''
	66064	+ case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
65453	66065	{
65454		- state.addr = 18446744073709547730LLU; // 99999999CR'''''''''''''''
	66066	+ state.addr = 18446744073709547690LLU; // 99999999Bo'''''''''''''''
65455	66067	break;
65456	66068	}
65457		- case 18446744073709547730LLU: // 99999999CR'''''''''''''''
	66069	+ case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
65458	66070	{
65459	66071	// ACCUMULATE ARGUMENTS - BEGIN
65460	66072	{

		@@ -65462,7 +66074,7 @@
65462	66074	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65463	66075	}
65464	66076	// ACCUMULATE ARGUMENTS - END
65465		- uint64_t return_to = 18446744073709547727LLU;
	66077	+ uint64_t return_to = 18446744073709547687LLU;
65466	66078	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65467	66079	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65468	66080	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65471,12 +66083,12 @@
65471	66083	state.addr = 839519719621918720LLU; // skipws____
65472	66084	break;
65473	66085	}
65474		- case 18446744073709547727LLU: // 99999999CO'''''''''''''''
	66086	+ case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
65475	66087	{
65476		- state.addr = 18446744073709547728LLU; // 99999999CP'''''''''''''''
	66088	+ state.addr = 18446744073709547688LLU; // 99999999Bm'''''''''''''''
65477	66089	break;
65478	66090	}
65479		- case 18446744073709547728LLU: // 99999999CP'''''''''''''''
	66091	+ case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
65480	66092	{
65481	66093	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
65482	66094	fprintf(stdout, "%s", "\n ");

		@@ -65490,7 +66102,7 @@
65490	66102	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65491	66103	}
65492	66104	// ACCUMULATE ARGUMENTS - END
65493		- uint64_t return_to = 18446744073709547724LLU;
	66105	+ uint64_t return_to = 18446744073709547684LLU;
65494	66106	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65495	66107	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65496	66108	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65499,12 +66111,12 @@
65499	66111	state.addr = 839519719621918720LLU; // skipws____
65500	66112	break;
65501	66113	}
65502		- case 18446744073709547724LLU: // 99999999CL'''''''''''''''
	66114	+ case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
65503	66115	{
65504		- state.addr = 18446744073709547725LLU; // 99999999CM'''''''''''''''
	66116	+ state.addr = 18446744073709547685LLU; // 99999999Bj'''''''''''''''
65505	66117	break;
65506	66118	}
65507		- case 18446744073709547725LLU: // 99999999CM'''''''''''''''
	66119	+ case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
65508	66120	{
65509	66121	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
65510	66122	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -65525,7 +66137,7 @@
65525	66137	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65526	66138	}
65527	66139	// ACCUMULATE ARGUMENTS - END
65528		- uint64_t return_to = 18446744073709547722LLU;
	66140	+ uint64_t return_to = 18446744073709547682LLU;
65529	66141	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
65530	66142	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65531	66143	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65534,12 +66146,12 @@
65534	66146	state.addr = 517555565473470767LLU; // assertinit
65535	66147	break;
65536	66148	}
65537		- case 18446744073709547722LLU: // 99999999CJ'''''''''''''''
	66149	+ case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
65538	66150	{
65539		- state.addr = 18446744073709547723LLU; // 99999999CK'''''''''''''''
	66151	+ state.addr = 18446744073709547683LLU; // 99999999Bh'''''''''''''''
65540	66152	break;
65541	66153	}
65542		- case 18446744073709547723LLU: // 99999999CK'''''''''''''''
	66154	+ case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
65543	66155	{
65544	66156	{
65545	66157	uint64_t arg = 0LLU;

		@@ -65615,7 +66227,7 @@
65615	66227	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65616	66228	}
65617	66229	// ACCUMULATE ARGUMENTS - END
65618		- uint64_t return_to = 18446744073709547720LLU;
	66230	+ uint64_t return_to = 18446744073709547680LLU;
65619	66231	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
65620	66232	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65621	66233	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65624,12 +66236,12 @@
65624	66236	state.addr = 787472342492567585LLU; // procvarref
65625	66237	break;
65626	66238	}
65627		- case 18446744073709547720LLU: // 99999999CH'''''''''''''''
	66239	+ case 18446744073709547680LLU: // 99999999Be'''''''''''''''
65628	66240	{
65629		- state.addr = 18446744073709547721LLU; // 99999999CI'''''''''''''''
	66241	+ state.addr = 18446744073709547681LLU; // 99999999Bf'''''''''''''''
65630	66242	break;
65631	66243	}
65632		- case 18446744073709547721LLU: // 99999999CI'''''''''''''''
	66244	+ case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
65633	66245	{
65634	66246	// variable u64 initialize goes out of scope
65635	66247	// emitted destructur for type u64

		@@ -65640,10 +66252,10 @@
65640	66252	// variable u64 idx_______ goes out of scope
65641	66253	// emitted destructur for type u64
65642	66254	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
65643		- state.addr = 18446744073709547726LLU; // 99999999CN'''''''''''''''
	66255	+ state.addr = 18446744073709547686LLU; // 99999999Bk'''''''''''''''
65644	66256	break;
65645	66257	}
65646		- case 18446744073709547726LLU: // 99999999CN'''''''''''''''
	66258	+ case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
65647	66259	{
65648	66260	fprintf(stdout, "%s", " = (uint64_t)ungetc(getchar(), stdin);");
65649	66261	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -65652,7 +66264,7 @@
65652	66264	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65653	66265	}
65654	66266	// ACCUMULATE ARGUMENTS - END
65655		- uint64_t return_to = 18446744073709547718LLU;
	66267	+ uint64_t return_to = 18446744073709547678LLU;
65656	66268	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65657	66269	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65658	66270	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65661,12 +66273,12 @@
65661	66273	state.addr = 839519719621918720LLU; // skipws____
65662	66274	break;
65663	66275	}
65664		- case 18446744073709547718LLU: // 99999999CF'''''''''''''''
	66276	+ case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
65665	66277	{
65666		- state.addr = 18446744073709547719LLU; // 99999999CG'''''''''''''''
	66278	+ state.addr = 18446744073709547679LLU; // 99999999Bd'''''''''''''''
65667	66279	break;
65668	66280	}
65669		- case 18446744073709547719LLU: // 99999999CG'''''''''''''''
	66281	+ case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
65670	66282	{
65671	66283	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
65672	66284	if(')' != (char)getchar())

		@@ -65684,7 +66296,7 @@
65684	66296	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65685	66297	}
65686	66298	// ACCUMULATE ARGUMENTS - END
65687		- uint64_t return_to = 18446744073709547716LLU;
	66299	+ uint64_t return_to = 18446744073709547676LLU;
65688	66300	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
65689	66301	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65690	66302	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65693,12 +66305,12 @@
65693	66305	state.addr = 517555565476695680LLU; // assertu64_
65694	66306	break;
65695	66307	}
65696		- case 18446744073709547716LLU: // 99999999CD'''''''''''''''
	66308	+ case 18446744073709547676LLU: // 99999999Ba'''''''''''''''
65697	66309	{
65698		- state.addr = 18446744073709547717LLU; // 99999999CE'''''''''''''''
	66310	+ state.addr = 18446744073709547677LLU; // 99999999Bb'''''''''''''''
65699	66311	break;
65700	66312	}
65701		- case 18446744073709547717LLU: // 99999999CE'''''''''''''''
	66313	+ case 18446744073709547677LLU: // 99999999Bb'''''''''''''''
65702	66314	{
65703	66315	{
65704	66316	uint64_t arg = 1LLU;

		@@ -65726,7 +66338,7 @@
65726	66338	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65727	66339	}
65728	66340	// ACCUMULATE ARGUMENTS - END
65729		- uint64_t return_to = 18446744073709547713LLU;
	66341	+ uint64_t return_to = 18446744073709547673LLU;
65730	66342	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
65731	66343	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65732	66344	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65735,20 +66347,20 @@
65735	66347	state.addr = 734295421765213120LLU; // mutassert_
65736	66348	break;
65737	66349	}
65738		- case 18446744073709547713LLU: // 99999999CA'''''''''''''''
	66350	+ case 18446744073709547673LLU: // 99999999BY'''''''''''''''
65739	66351	{
65740		- state.addr = 18446744073709547714LLU; // 99999999CB'''''''''''''''
	66352	+ state.addr = 18446744073709547674LLU; // 99999999BZ'''''''''''''''
65741	66353	break;
65742	66354	}
65743		- case 18446744073709547714LLU: // 99999999CB'''''''''''''''
	66355	+ case 18446744073709547674LLU: // 99999999BZ'''''''''''''''
65744	66356	{
65745	66357	// variable u64 parnr_____ goes out of scope
65746	66358	// emitted destructur for type u64
65747	66359	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
65748		- state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
	66360	+ state.addr = 18446744073709547675LLU; // 99999999B$'''''''''''''''
65749	66361	break;
65750	66362	}
65751		- case 18446744073709547715LLU: // 99999999CC'''''''''''''''
	66363	+ case 18446744073709547675LLU: // 99999999B$'''''''''''''''
65752	66364	{
65753	66365	// variable u64 mutable___ goes out of scope
65754	66366	// emitted destructur for type u64

		@@ -65761,7 +66373,7 @@
65761	66373	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65762	66374	}
65763	66375	// ACCUMULATE ARGUMENTS - END
65764		- uint64_t return_to = 18446744073709547712LLU;
	66376	+ uint64_t return_to = 18446744073709547672LLU;
65765	66377	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65766	66378	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65767	66379	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65770,7 +66382,7 @@
65770	66382	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
65771	66383	break;
65772	66384	}
65773		- case 18446744073709547712LLU: // 99999999C_'''''''''''''''
	66385	+ case 18446744073709547672LLU: // 99999999BX'''''''''''''''
65774	66386	{
65775	66387	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
65776	66388	// variable u64 INDIRECT__ goes out of scope

		@@ -65781,18 +66393,18 @@
65781	66393	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
65782	66394	heap.availilable_size_for_dynamic_objects += 0LLU;
65783	66395	heap.availilable_size_for_dynamic_objects += 0LLU;
65784		- state.addr = 18446744073709547711LLU; // 99999999B9'''''''''''''''
	66396	+ state.addr = 18446744073709547671LLU; // 99999999BW'''''''''''''''
65785	66397	break;
65786	66398	}
65787		- case 18446744073709547731LLU: // 99999999CS'''''''''''''''
	66399	+ case 18446744073709547691LLU: // 99999999Bp'''''''''''''''
65788	66400	{
65789	66401	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708110622720LLU;
65790	66402
65791	66403	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
65792		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547710LLU : 18446744073709547709LLU;
	66404	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547670LLU : 18446744073709547669LLU;
65793	66405	break;
65794	66406	}
65795		- case 18446744073709547710LLU: // 99999999B8'''''''''''''''
	66407	+ case 18446744073709547670LLU: // 99999999BV'''''''''''''''
65796	66408	{
65797	66409	{
65798	66410	uint64_t arg = 0LLU;

		@@ -65812,7 +66424,7 @@
65812	66424	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65813	66425	}
65814	66426	// ACCUMULATE ARGUMENTS - END
65815		- uint64_t return_to = 18446744073709547707LLU;
	66427	+ uint64_t return_to = 18446744073709547667LLU;
65816	66428	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65817	66429	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65818	66430	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65821,12 +66433,12 @@
65821	66433	state.addr = 861504796319285248LLU; // typeu64___
65822	66434	break;
65823	66435	}
65824		- case 18446744073709547707LLU: // 99999999B5'''''''''''''''
	66436	+ case 18446744073709547667LLU: // 99999999BS'''''''''''''''
65825	66437	{
65826		- state.addr = 18446744073709547708LLU; // 99999999B6'''''''''''''''
	66438	+ state.addr = 18446744073709547668LLU; // 99999999BT'''''''''''''''
65827	66439	break;
65828	66440	}
65829		- case 18446744073709547708LLU: // 99999999B6'''''''''''''''
	66441	+ case 18446744073709547668LLU: // 99999999BT'''''''''''''''
65830	66442	{
65831	66443	// ACCUMULATE ARGUMENTS - BEGIN
65832	66444	{

		@@ -65834,7 +66446,7 @@
65834	66446	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65835	66447	}
65836	66448	// ACCUMULATE ARGUMENTS - END
65837		- uint64_t return_to = 18446744073709547705LLU;
	66449	+ uint64_t return_to = 18446744073709547665LLU;
65838	66450	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65839	66451	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65840	66452	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65843,12 +66455,12 @@
65843	66455	state.addr = 839519719621918720LLU; // skipws____
65844	66456	break;
65845	66457	}
65846		- case 18446744073709547705LLU: // 99999999B3'''''''''''''''
	66458	+ case 18446744073709547665LLU: // 99999999BQ'''''''''''''''
65847	66459	{
65848		- state.addr = 18446744073709547706LLU; // 99999999B4'''''''''''''''
	66460	+ state.addr = 18446744073709547666LLU; // 99999999BR'''''''''''''''
65849	66461	break;
65850	66462	}
65851		- case 18446744073709547706LLU: // 99999999B4'''''''''''''''
	66463	+ case 18446744073709547666LLU: // 99999999BR'''''''''''''''
65852	66464	{
65853	66465	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
65854	66466	fprintf(stdout, "%s", "\n printid(stdout, ");

		@@ -65862,7 +66474,7 @@
65862	66474	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65863	66475	}
65864	66476	// ACCUMULATE ARGUMENTS - END
65865		- uint64_t return_to = 18446744073709547702LLU;
	66477	+ uint64_t return_to = 18446744073709547662LLU;
65866	66478	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
65867	66479	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65868	66480	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65871,12 +66483,12 @@
65871	66483	state.addr = 839519719621918720LLU; // skipws____
65872	66484	break;
65873	66485	}
65874		- case 18446744073709547702LLU: // 99999999B0'''''''''''''''
	66486	+ case 18446744073709547662LLU: // 99999999BN'''''''''''''''
65875	66487	{
65876		- state.addr = 18446744073709547703LLU; // 99999999B1'''''''''''''''
	66488	+ state.addr = 18446744073709547663LLU; // 99999999BO'''''''''''''''
65877	66489	break;
65878	66490	}
65879		- case 18446744073709547703LLU: // 99999999B1'''''''''''''''
	66491	+ case 18446744073709547663LLU: // 99999999BO'''''''''''''''
65880	66492	{
65881	66493	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
65882	66494	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -65897,7 +66509,7 @@
65897	66509	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65898	66510	}
65899	66511	// ACCUMULATE ARGUMENTS - END
65900		- uint64_t return_to = 18446744073709547700LLU;
	66512	+ uint64_t return_to = 18446744073709547660LLU;
65901	66513	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
65902	66514	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65903	66515	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65906,12 +66518,12 @@
65906	66518	state.addr = 517555565473470767LLU; // assertinit
65907	66519	break;
65908	66520	}
65909		- case 18446744073709547700LLU: // 99999999By'''''''''''''''
	66521	+ case 18446744073709547660LLU: // 99999999BL'''''''''''''''
65910	66522	{
65911		- state.addr = 18446744073709547701LLU; // 99999999Bz'''''''''''''''
	66523	+ state.addr = 18446744073709547661LLU; // 99999999BM'''''''''''''''
65912	66524	break;
65913	66525	}
65914		- case 18446744073709547701LLU: // 99999999Bz'''''''''''''''
	66526	+ case 18446744073709547661LLU: // 99999999BM'''''''''''''''
65915	66527	{
65916	66528	{
65917	66529	uint64_t arg = 0LLU;

		@@ -65987,7 +66599,7 @@
65987	66599	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
65988	66600	}
65989	66601	// ACCUMULATE ARGUMENTS - END
65990		- uint64_t return_to = 18446744073709547698LLU;
	66602	+ uint64_t return_to = 18446744073709547658LLU;
65991	66603	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
65992	66604	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
65993	66605	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -65996,12 +66608,12 @@
65996	66608	state.addr = 787472342492567585LLU; // procvarref
65997	66609	break;
65998	66610	}
65999		- case 18446744073709547698LLU: // 99999999Bw'''''''''''''''
	66611	+ case 18446744073709547658LLU: // 99999999BJ'''''''''''''''
66000	66612	{
66001		- state.addr = 18446744073709547699LLU; // 99999999Bx'''''''''''''''
	66613	+ state.addr = 18446744073709547659LLU; // 99999999BK'''''''''''''''
66002	66614	break;
66003	66615	}
66004		- case 18446744073709547699LLU: // 99999999Bx'''''''''''''''
	66616	+ case 18446744073709547659LLU: // 99999999BK'''''''''''''''
66005	66617	{
66006	66618	// variable u64 initialize goes out of scope
66007	66619	// emitted destructur for type u64

		@@ -66012,10 +66624,10 @@
66012	66624	// variable u64 idx_______ goes out of scope
66013	66625	// emitted destructur for type u64
66014	66626	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
66015		- state.addr = 18446744073709547704LLU; // 99999999B2'''''''''''''''
	66627	+ state.addr = 18446744073709547664LLU; // 99999999BP'''''''''''''''
66016	66628	break;
66017	66629	}
66018		- case 18446744073709547704LLU: // 99999999B2'''''''''''''''
	66630	+ case 18446744073709547664LLU: // 99999999BP'''''''''''''''
66019	66631	{
66020	66632	fprintf(stdout, "%s", ");");
66021	66633	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66024,7 +66636,7 @@
66024	66636	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66025	66637	}
66026	66638	// ACCUMULATE ARGUMENTS - END
66027		- uint64_t return_to = 18446744073709547696LLU;
	66639	+ uint64_t return_to = 18446744073709547656LLU;
66028	66640	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66029	66641	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66030	66642	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66033,12 +66645,12 @@
66033	66645	state.addr = 839519719621918720LLU; // skipws____
66034	66646	break;
66035	66647	}
66036		- case 18446744073709547696LLU: // 99999999Bu'''''''''''''''
	66648	+ case 18446744073709547656LLU: // 99999999BH'''''''''''''''
66037	66649	{
66038		- state.addr = 18446744073709547697LLU; // 99999999Bv'''''''''''''''
	66650	+ state.addr = 18446744073709547657LLU; // 99999999BI'''''''''''''''
66039	66651	break;
66040	66652	}
66041		- case 18446744073709547697LLU: // 99999999Bv'''''''''''''''
	66653	+ case 18446744073709547657LLU: // 99999999BI'''''''''''''''
66042	66654	{
66043	66655	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
66044	66656	if(')' != (char)getchar())

		@@ -66056,7 +66668,7 @@
66056	66668	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66057	66669	}
66058	66670	// ACCUMULATE ARGUMENTS - END
66059		- uint64_t return_to = 18446744073709547694LLU;
	66671	+ uint64_t return_to = 18446744073709547654LLU;
66060	66672	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
66061	66673	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66062	66674	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66065,12 +66677,12 @@
66065	66677	state.addr = 517555565476695680LLU; // assertu64_
66066	66678	break;
66067	66679	}
66068		- case 18446744073709547694LLU: // 99999999Bs'''''''''''''''
	66680	+ case 18446744073709547654LLU: // 99999999BF'''''''''''''''
66069	66681	{
66070		- state.addr = 18446744073709547695LLU; // 99999999Bt'''''''''''''''
	66682	+ state.addr = 18446744073709547655LLU; // 99999999BG'''''''''''''''
66071	66683	break;
66072	66684	}
66073		- case 18446744073709547695LLU: // 99999999Bt'''''''''''''''
	66685	+ case 18446744073709547655LLU: // 99999999BG'''''''''''''''
66074	66686	{
66075	66687	// variable u64 mutable___ goes out of scope
66076	66688	// emitted destructur for type u64

		@@ -66083,7 +66695,7 @@
66083	66695	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66084	66696	}
66085	66697	// ACCUMULATE ARGUMENTS - END
66086		- uint64_t return_to = 18446744073709547693LLU;
	66698	+ uint64_t return_to = 18446744073709547653LLU;
66087	66699	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66088	66700	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66089	66701	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66092,7 +66704,7 @@
66092	66704	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
66093	66705	break;
66094	66706	}
66095		- case 18446744073709547693LLU: // 99999999Br'''''''''''''''
	66707	+ case 18446744073709547653LLU: // 99999999BE'''''''''''''''
66096	66708	{
66097	66709	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
66098	66710	// variable u64 INDIRECT__ goes out of scope

		@@ -66103,18 +66715,18 @@
66103	66715	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
66104	66716	heap.availilable_size_for_dynamic_objects += 0LLU;
66105	66717	heap.availilable_size_for_dynamic_objects += 0LLU;
66106		- state.addr = 18446744073709547692LLU; // 99999999Bq'''''''''''''''
	66718	+ state.addr = 18446744073709547652LLU; // 99999999BD'''''''''''''''
66107	66719	break;
66108	66720	}
66109		- case 18446744073709547709LLU: // 99999999B7'''''''''''''''
	66721	+ case 18446744073709547669LLU: // 99999999BU'''''''''''''''
66110	66722	{
66111	66723	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183515906048LLU;
66112	66724
66113	66725	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66114		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547691LLU : 18446744073709547690LLU;
	66726	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547651LLU : 18446744073709547650LLU;
66115	66727	break;
66116	66728	}
66117		- case 18446744073709547691LLU: // 99999999Bp'''''''''''''''
	66729	+ case 18446744073709547651LLU: // 99999999BC'''''''''''''''
66118	66730	{
66119	66731	{
66120	66732	uint64_t arg = 0LLU;

		@@ -66134,7 +66746,7 @@
66134	66746	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66135	66747	}
66136	66748	// ACCUMULATE ARGUMENTS - END
66137		- uint64_t return_to = 18446744073709547688LLU;
	66749	+ uint64_t return_to = 18446744073709547648LLU;
66138	66750	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66139	66751	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66140	66752	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66143,12 +66755,12 @@
66143	66755	state.addr = 861504796319285248LLU; // typeu64___
66144	66756	break;
66145	66757	}
66146		- case 18446744073709547688LLU: // 99999999Bm'''''''''''''''
	66758	+ case 18446744073709547648LLU: // 99999999B_'''''''''''''''
66147	66759	{
66148		- state.addr = 18446744073709547689LLU; // 99999999Bn'''''''''''''''
	66760	+ state.addr = 18446744073709547649LLU; // 99999999BA'''''''''''''''
66149	66761	break;
66150	66762	}
66151		- case 18446744073709547689LLU: // 99999999Bn'''''''''''''''
	66763	+ case 18446744073709547649LLU: // 99999999BA'''''''''''''''
66152	66764	{
66153	66765	// ACCUMULATE ARGUMENTS - BEGIN
66154	66766	{

		@@ -66156,7 +66768,7 @@
66156	66768	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66157	66769	}
66158	66770	// ACCUMULATE ARGUMENTS - END
66159		- uint64_t return_to = 18446744073709547686LLU;
	66771	+ uint64_t return_to = 18446744073709547646LLU;
66160	66772	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66161	66773	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66162	66774	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66165,12 +66777,12 @@
66165	66777	state.addr = 839519719621918720LLU; // skipws____
66166	66778	break;
66167	66779	}
66168		- case 18446744073709547686LLU: // 99999999Bk'''''''''''''''
	66780	+ case 18446744073709547646LLU: // 99999999A8'''''''''''''''
66169	66781	{
66170		- state.addr = 18446744073709547687LLU; // 99999999Bl'''''''''''''''
	66782	+ state.addr = 18446744073709547647LLU; // 99999999A9'''''''''''''''
66171	66783	break;
66172	66784	}
66173		- case 18446744073709547687LLU: // 99999999Bl'''''''''''''''
	66785	+ case 18446744073709547647LLU: // 99999999A9'''''''''''''''
66174	66786	{
66175	66787	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
66176	66788	fprintf(stdout, "%s", "\n printid(stderr, ");

		@@ -66184,7 +66796,7 @@
66184	66796	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66185	66797	}
66186	66798	// ACCUMULATE ARGUMENTS - END
66187		- uint64_t return_to = 18446744073709547683LLU;
	66799	+ uint64_t return_to = 18446744073709547643LLU;
66188	66800	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66189	66801	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66190	66802	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66193,12 +66805,12 @@
66193	66805	state.addr = 839519719621918720LLU; // skipws____
66194	66806	break;
66195	66807	}
66196		- case 18446744073709547683LLU: // 99999999Bh'''''''''''''''
	66808	+ case 18446744073709547643LLU: // 99999999A5'''''''''''''''
66197	66809	{
66198		- state.addr = 18446744073709547684LLU; // 99999999Bi'''''''''''''''
	66810	+ state.addr = 18446744073709547644LLU; // 99999999A6'''''''''''''''
66199	66811	break;
66200	66812	}
66201		- case 18446744073709547684LLU: // 99999999Bi'''''''''''''''
	66813	+ case 18446744073709547644LLU: // 99999999A6'''''''''''''''
66202	66814	{
66203	66815	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
66204	66816	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66219,7 +66831,7 @@
66219	66831	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66220	66832	}
66221	66833	// ACCUMULATE ARGUMENTS - END
66222		- uint64_t return_to = 18446744073709547681LLU;
	66834	+ uint64_t return_to = 18446744073709547641LLU;
66223	66835	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
66224	66836	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66225	66837	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66228,12 +66840,12 @@
66228	66840	state.addr = 517555565473470767LLU; // assertinit
66229	66841	break;
66230	66842	}
66231		- case 18446744073709547681LLU: // 99999999Bf'''''''''''''''
	66843	+ case 18446744073709547641LLU: // 99999999A3'''''''''''''''
66232	66844	{
66233		- state.addr = 18446744073709547682LLU; // 99999999Bg'''''''''''''''
	66845	+ state.addr = 18446744073709547642LLU; // 99999999A4'''''''''''''''
66234	66846	break;
66235	66847	}
66236		- case 18446744073709547682LLU: // 99999999Bg'''''''''''''''
	66848	+ case 18446744073709547642LLU: // 99999999A4'''''''''''''''
66237	66849	{
66238	66850	{
66239	66851	uint64_t arg = 0LLU;

		@@ -66309,7 +66921,7 @@
66309	66921	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66310	66922	}
66311	66923	// ACCUMULATE ARGUMENTS - END
66312		- uint64_t return_to = 18446744073709547679LLU;
	66924	+ uint64_t return_to = 18446744073709547639LLU;
66313	66925	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
66314	66926	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66315	66927	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66318,12 +66930,12 @@
66318	66930	state.addr = 787472342492567585LLU; // procvarref
66319	66931	break;
66320	66932	}
66321		- case 18446744073709547679LLU: // 99999999Bd'''''''''''''''
	66933	+ case 18446744073709547639LLU: // 99999999A1'''''''''''''''
66322	66934	{
66323		- state.addr = 18446744073709547680LLU; // 99999999Be'''''''''''''''
	66935	+ state.addr = 18446744073709547640LLU; // 99999999A2'''''''''''''''
66324	66936	break;
66325	66937	}
66326		- case 18446744073709547680LLU: // 99999999Be'''''''''''''''
	66938	+ case 18446744073709547640LLU: // 99999999A2'''''''''''''''
66327	66939	{
66328	66940	// variable u64 initialize goes out of scope
66329	66941	// emitted destructur for type u64

		@@ -66334,10 +66946,10 @@
66334	66946	// variable u64 idx_______ goes out of scope
66335	66947	// emitted destructur for type u64
66336	66948	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
66337		- state.addr = 18446744073709547685LLU; // 99999999Bj'''''''''''''''
	66949	+ state.addr = 18446744073709547645LLU; // 99999999A7'''''''''''''''
66338	66950	break;
66339	66951	}
66340		- case 18446744073709547685LLU: // 99999999Bj'''''''''''''''
	66952	+ case 18446744073709547645LLU: // 99999999A7'''''''''''''''
66341	66953	{
66342	66954	fprintf(stdout, "%s", ");");
66343	66955	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66346,7 +66958,7 @@
66346	66958	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66347	66959	}
66348	66960	// ACCUMULATE ARGUMENTS - END
66349		- uint64_t return_to = 18446744073709547677LLU;
	66961	+ uint64_t return_to = 18446744073709547637LLU;
66350	66962	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66351	66963	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66352	66964	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66355,12 +66967,12 @@
66355	66967	state.addr = 839519719621918720LLU; // skipws____
66356	66968	break;
66357	66969	}
66358		- case 18446744073709547677LLU: // 99999999Bb'''''''''''''''
	66970	+ case 18446744073709547637LLU: // 99999999Az'''''''''''''''
66359	66971	{
66360		- state.addr = 18446744073709547678LLU; // 99999999Bc'''''''''''''''
	66972	+ state.addr = 18446744073709547638LLU; // 99999999A0'''''''''''''''
66361	66973	break;
66362	66974	}
66363		- case 18446744073709547678LLU: // 99999999Bc'''''''''''''''
	66975	+ case 18446744073709547638LLU: // 99999999A0'''''''''''''''
66364	66976	{
66365	66977	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
66366	66978	if(')' != (char)getchar())

		@@ -66378,7 +66990,7 @@
66378	66990	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66379	66991	}
66380	66992	// ACCUMULATE ARGUMENTS - END
66381		- uint64_t return_to = 18446744073709547675LLU;
	66993	+ uint64_t return_to = 18446744073709547635LLU;
66382	66994	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
66383	66995	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66384	66996	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66387,12 +66999,12 @@
66387	66999	state.addr = 517555565476695680LLU; // assertu64_
66388	67000	break;
66389	67001	}
66390		- case 18446744073709547675LLU: // 99999999B$'''''''''''''''
	67002	+ case 18446744073709547635LLU: // 99999999Ax'''''''''''''''
66391	67003	{
66392		- state.addr = 18446744073709547676LLU; // 99999999Ba'''''''''''''''
	67004	+ state.addr = 18446744073709547636LLU; // 99999999Ay'''''''''''''''
66393	67005	break;
66394	67006	}
66395		- case 18446744073709547676LLU: // 99999999Ba'''''''''''''''
	67007	+ case 18446744073709547636LLU: // 99999999Ay'''''''''''''''
66396	67008	{
66397	67009	// variable u64 mutable___ goes out of scope
66398	67010	// emitted destructur for type u64

		@@ -66405,7 +67017,7 @@
66405	67017	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66406	67018	}
66407	67019	// ACCUMULATE ARGUMENTS - END
66408		- uint64_t return_to = 18446744073709547674LLU;
	67020	+ uint64_t return_to = 18446744073709547634LLU;
66409	67021	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66410	67022	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66411	67023	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66414,7 +67026,7 @@
66414	67026	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
66415	67027	break;
66416	67028	}
66417		- case 18446744073709547674LLU: // 99999999BZ'''''''''''''''
	67029	+ case 18446744073709547634LLU: // 99999999Aw'''''''''''''''
66418	67030	{
66419	67031	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
66420	67032	// variable u64 INDIRECT__ goes out of scope

		@@ -66425,18 +67037,18 @@
66425	67037	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
66426	67038	heap.availilable_size_for_dynamic_objects += 0LLU;
66427	67039	heap.availilable_size_for_dynamic_objects += 0LLU;
66428		- state.addr = 18446744073709547673LLU; // 99999999BY'''''''''''''''
	67040	+ state.addr = 18446744073709547633LLU; // 99999999Av'''''''''''''''
66429	67041	break;
66430	67042	}
66431		- case 18446744073709547690LLU: // 99999999Bo'''''''''''''''
	67043	+ case 18446744073709547650LLU: // 99999999BB'''''''''''''''
66432	67044	{
66433	67045	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 660190761781821440LLU;
66434	67046
66435	67047	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66436		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547672LLU : 18446744073709547671LLU;
	67048	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547632LLU : 18446744073709547631LLU;
66437	67049	break;
66438	67050	}
66439		- case 18446744073709547672LLU: // 99999999BX'''''''''''''''
	67051	+ case 18446744073709547632LLU: // 99999999Au'''''''''''''''
66440	67052	{
66441	67053	{
66442	67054	uint64_t arg = 0LLU;

		@@ -66456,7 +67068,7 @@
66456	67068	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66457	67069	}
66458	67070	// ACCUMULATE ARGUMENTS - END
66459		- uint64_t return_to = 18446744073709547669LLU;
	67071	+ uint64_t return_to = 18446744073709547629LLU;
66460	67072	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66461	67073	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66462	67074	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66465,12 +67077,12 @@
66465	67077	state.addr = 861504796319285248LLU; // typeu64___
66466	67078	break;
66467	67079	}
66468		- case 18446744073709547669LLU: // 99999999BU'''''''''''''''
	67080	+ case 18446744073709547629LLU: // 99999999Ar'''''''''''''''
66469	67081	{
66470		- state.addr = 18446744073709547670LLU; // 99999999BV'''''''''''''''
	67082	+ state.addr = 18446744073709547630LLU; // 99999999As'''''''''''''''
66471	67083	break;
66472	67084	}
66473		- case 18446744073709547670LLU: // 99999999BV'''''''''''''''
	67085	+ case 18446744073709547630LLU: // 99999999As'''''''''''''''
66474	67086	{
66475	67087	// ACCUMULATE ARGUMENTS - BEGIN
66476	67088	{

		@@ -66478,7 +67090,7 @@
66478	67090	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66479	67091	}
66480	67092	// ACCUMULATE ARGUMENTS - END
66481		- uint64_t return_to = 18446744073709547667LLU;
	67093	+ uint64_t return_to = 18446744073709547627LLU;
66482	67094	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66483	67095	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66484	67096	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66487,12 +67099,12 @@
66487	67099	state.addr = 839519719621918720LLU; // skipws____
66488	67100	break;
66489	67101	}
66490		- case 18446744073709547667LLU: // 99999999BS'''''''''''''''
	67102	+ case 18446744073709547627LLU: // 99999999Ap'''''''''''''''
66491	67103	{
66492		- state.addr = 18446744073709547668LLU; // 99999999BT'''''''''''''''
	67104	+ state.addr = 18446744073709547628LLU; // 99999999Aq'''''''''''''''
66493	67105	break;
66494	67106	}
66495		- case 18446744073709547668LLU: // 99999999BT'''''''''''''''
	67107	+ case 18446744073709547628LLU: // 99999999Aq'''''''''''''''
66496	67108	{
66497	67109	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
66498	67110	fprintf(stdout, "%s", "\n ++");

		@@ -66506,7 +67118,7 @@
66506	67118	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66507	67119	}
66508	67120	// ACCUMULATE ARGUMENTS - END
66509		- uint64_t return_to = 18446744073709547664LLU;
	67121	+ uint64_t return_to = 18446744073709547624LLU;
66510	67122	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66511	67123	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66512	67124	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66515,12 +67127,12 @@
66515	67127	state.addr = 839519719621918720LLU; // skipws____
66516	67128	break;
66517	67129	}
66518		- case 18446744073709547664LLU: // 99999999BP'''''''''''''''
	67130	+ case 18446744073709547624LLU: // 99999999Am'''''''''''''''
66519	67131	{
66520		- state.addr = 18446744073709547665LLU; // 99999999BQ'''''''''''''''
	67132	+ state.addr = 18446744073709547625LLU; // 99999999An'''''''''''''''
66521	67133	break;
66522	67134	}
66523		- case 18446744073709547665LLU: // 99999999BQ'''''''''''''''
	67135	+ case 18446744073709547625LLU: // 99999999An'''''''''''''''
66524	67136	{
66525	67137	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
66526	67138	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66541,7 +67153,7 @@
66541	67153	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66542	67154	}
66543	67155	// ACCUMULATE ARGUMENTS - END
66544		- uint64_t return_to = 18446744073709547662LLU;
	67156	+ uint64_t return_to = 18446744073709547622LLU;
66545	67157	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
66546	67158	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66547	67159	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66550,12 +67162,12 @@
66550	67162	state.addr = 517555565473470767LLU; // assertinit
66551	67163	break;
66552	67164	}
66553		- case 18446744073709547662LLU: // 99999999BN'''''''''''''''
	67165	+ case 18446744073709547622LLU: // 99999999Ak'''''''''''''''
66554	67166	{
66555		- state.addr = 18446744073709547663LLU; // 99999999BO'''''''''''''''
	67167	+ state.addr = 18446744073709547623LLU; // 99999999Al'''''''''''''''
66556	67168	break;
66557	67169	}
66558		- case 18446744073709547663LLU: // 99999999BO'''''''''''''''
	67170	+ case 18446744073709547623LLU: // 99999999Al'''''''''''''''
66559	67171	{
66560	67172	{
66561	67173	uint64_t arg = 0LLU;

		@@ -66631,7 +67243,7 @@
66631	67243	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66632	67244	}
66633	67245	// ACCUMULATE ARGUMENTS - END
66634		- uint64_t return_to = 18446744073709547660LLU;
	67246	+ uint64_t return_to = 18446744073709547620LLU;
66635	67247	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
66636	67248	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66637	67249	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66640,12 +67252,12 @@
66640	67252	state.addr = 787472342492567585LLU; // procvarref
66641	67253	break;
66642	67254	}
66643		- case 18446744073709547660LLU: // 99999999BL'''''''''''''''
	67255	+ case 18446744073709547620LLU: // 99999999Ai'''''''''''''''
66644	67256	{
66645		- state.addr = 18446744073709547661LLU; // 99999999BM'''''''''''''''
	67257	+ state.addr = 18446744073709547621LLU; // 99999999Aj'''''''''''''''
66646	67258	break;
66647	67259	}
66648		- case 18446744073709547661LLU: // 99999999BM'''''''''''''''
	67260	+ case 18446744073709547621LLU: // 99999999Aj'''''''''''''''
66649	67261	{
66650	67262	// variable u64 initialize goes out of scope
66651	67263	// emitted destructur for type u64

		@@ -66656,10 +67268,10 @@
66656	67268	// variable u64 idx_______ goes out of scope
66657	67269	// emitted destructur for type u64
66658	67270	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
66659		- state.addr = 18446744073709547666LLU; // 99999999BR'''''''''''''''
	67271	+ state.addr = 18446744073709547626LLU; // 99999999Ao'''''''''''''''
66660	67272	break;
66661	67273	}
66662		- case 18446744073709547666LLU: // 99999999BR'''''''''''''''
	67274	+ case 18446744073709547626LLU: // 99999999Ao'''''''''''''''
66663	67275	{
66664	67276	fprintf(stdout, "%s", ";");
66665	67277	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66668,7 +67280,7 @@
66668	67280	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66669	67281	}
66670	67282	// ACCUMULATE ARGUMENTS - END
66671		- uint64_t return_to = 18446744073709547658LLU;
	67283	+ uint64_t return_to = 18446744073709547618LLU;
66672	67284	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66673	67285	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66674	67286	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66677,12 +67289,12 @@
66677	67289	state.addr = 839519719621918720LLU; // skipws____
66678	67290	break;
66679	67291	}
66680		- case 18446744073709547658LLU: // 99999999BJ'''''''''''''''
	67292	+ case 18446744073709547618LLU: // 99999999Ag'''''''''''''''
66681	67293	{
66682		- state.addr = 18446744073709547659LLU; // 99999999BK'''''''''''''''
	67294	+ state.addr = 18446744073709547619LLU; // 99999999Ah'''''''''''''''
66683	67295	break;
66684	67296	}
66685		- case 18446744073709547659LLU: // 99999999BK'''''''''''''''
	67297	+ case 18446744073709547619LLU: // 99999999Ah'''''''''''''''
66686	67298	{
66687	67299	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
66688	67300	if(')' != (char)getchar())

		@@ -66700,7 +67312,7 @@
66700	67312	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66701	67313	}
66702	67314	// ACCUMULATE ARGUMENTS - END
66703		- uint64_t return_to = 18446744073709547656LLU;
	67315	+ uint64_t return_to = 18446744073709547616LLU;
66704	67316	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
66705	67317	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66706	67318	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66709,12 +67321,12 @@
66709	67321	state.addr = 517555565476695680LLU; // assertu64_
66710	67322	break;
66711	67323	}
66712		- case 18446744073709547656LLU: // 99999999BH'''''''''''''''
	67324	+ case 18446744073709547616LLU: // 99999999Ae'''''''''''''''
66713	67325	{
66714		- state.addr = 18446744073709547657LLU; // 99999999BI'''''''''''''''
	67326	+ state.addr = 18446744073709547617LLU; // 99999999Af'''''''''''''''
66715	67327	break;
66716	67328	}
66717		- case 18446744073709547657LLU: // 99999999BI'''''''''''''''
	67329	+ case 18446744073709547617LLU: // 99999999Af'''''''''''''''
66718	67330	{
66719	67331	{
66720	67332	uint64_t arg = 1LLU;

		@@ -66742,7 +67354,7 @@
66742	67354	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66743	67355	}
66744	67356	// ACCUMULATE ARGUMENTS - END
66745		- uint64_t return_to = 18446744073709547653LLU;
	67357	+ uint64_t return_to = 18446744073709547613LLU;
66746	67358	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
66747	67359	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66748	67360	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66751,20 +67363,20 @@
66751	67363	state.addr = 734295421765213120LLU; // mutassert_
66752	67364	break;
66753	67365	}
66754		- case 18446744073709547653LLU: // 99999999BE'''''''''''''''
	67366	+ case 18446744073709547613LLU: // 99999999Ab'''''''''''''''
66755	67367	{
66756		- state.addr = 18446744073709547654LLU; // 99999999BF'''''''''''''''
	67368	+ state.addr = 18446744073709547614LLU; // 99999999Ac'''''''''''''''
66757	67369	break;
66758	67370	}
66759		- case 18446744073709547654LLU: // 99999999BF'''''''''''''''
	67371	+ case 18446744073709547614LLU: // 99999999Ac'''''''''''''''
66760	67372	{
66761	67373	// variable u64 parnr_____ goes out of scope
66762	67374	// emitted destructur for type u64
66763	67375	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
66764		- state.addr = 18446744073709547655LLU; // 99999999BG'''''''''''''''
	67376	+ state.addr = 18446744073709547615LLU; // 99999999Ad'''''''''''''''
66765	67377	break;
66766	67378	}
66767		- case 18446744073709547655LLU: // 99999999BG'''''''''''''''
	67379	+ case 18446744073709547615LLU: // 99999999Ad'''''''''''''''
66768	67380	{
66769	67381	// variable u64 mutable___ goes out of scope
66770	67382	// emitted destructur for type u64

		@@ -66777,7 +67389,7 @@
66777	67389	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66778	67390	}
66779	67391	// ACCUMULATE ARGUMENTS - END
66780		- uint64_t return_to = 18446744073709547652LLU;
	67392	+ uint64_t return_to = 18446744073709547612LLU;
66781	67393	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66782	67394	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66783	67395	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66786,7 +67398,7 @@
66786	67398	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
66787	67399	break;
66788	67400	}
66789		- case 18446744073709547652LLU: // 99999999BD'''''''''''''''
	67401	+ case 18446744073709547612LLU: // 99999999Aa'''''''''''''''
66790	67402	{
66791	67403	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
66792	67404	// variable u64 INDIRECT__ goes out of scope

		@@ -66797,18 +67409,18 @@
66797	67409	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
66798	67410	heap.availilable_size_for_dynamic_objects += 0LLU;
66799	67411	heap.availilable_size_for_dynamic_objects += 0LLU;
66800		- state.addr = 18446744073709547651LLU; // 99999999BC'''''''''''''''
	67412	+ state.addr = 18446744073709547611LLU; // 99999999A$'''''''''''''''
66801	67413	break;
66802	67414	}
66803		- case 18446744073709547671LLU: // 99999999BW'''''''''''''''
	67415	+ case 18446744073709547631LLU: // 99999999At'''''''''''''''
66804	67416	{
66805	67417	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 567585494444015616LLU;
66806	67418
66807	67419	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
66808		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547650LLU : 18446744073709547649LLU;
	67420	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547610LLU : 18446744073709547609LLU;
66809	67421	break;
66810	67422	}
66811		- case 18446744073709547650LLU: // 99999999BB'''''''''''''''
	67423	+ case 18446744073709547610LLU: // 99999999AZ'''''''''''''''
66812	67424	{
66813	67425	{
66814	67426	uint64_t arg = 0LLU;

		@@ -66828,7 +67440,7 @@
66828	67440	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66829	67441	}
66830	67442	// ACCUMULATE ARGUMENTS - END
66831		- uint64_t return_to = 18446744073709547647LLU;
	67443	+ uint64_t return_to = 18446744073709547607LLU;
66832	67444	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66833	67445	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66834	67446	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66837,12 +67449,12 @@
66837	67449	state.addr = 861504796319285248LLU; // typeu64___
66838	67450	break;
66839	67451	}
66840		- case 18446744073709547647LLU: // 99999999A9'''''''''''''''
	67452	+ case 18446744073709547607LLU: // 99999999AW'''''''''''''''
66841	67453	{
66842		- state.addr = 18446744073709547648LLU; // 99999999B_'''''''''''''''
	67454	+ state.addr = 18446744073709547608LLU; // 99999999AX'''''''''''''''
66843	67455	break;
66844	67456	}
66845		- case 18446744073709547648LLU: // 99999999B_'''''''''''''''
	67457	+ case 18446744073709547608LLU: // 99999999AX'''''''''''''''
66846	67458	{
66847	67459	// ACCUMULATE ARGUMENTS - BEGIN
66848	67460	{

		@@ -66850,7 +67462,7 @@
66850	67462	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66851	67463	}
66852	67464	// ACCUMULATE ARGUMENTS - END
66853		- uint64_t return_to = 18446744073709547645LLU;
	67465	+ uint64_t return_to = 18446744073709547605LLU;
66854	67466	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66855	67467	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66856	67468	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66859,12 +67471,12 @@
66859	67471	state.addr = 839519719621918720LLU; // skipws____
66860	67472	break;
66861	67473	}
66862		- case 18446744073709547645LLU: // 99999999A7'''''''''''''''
	67474	+ case 18446744073709547605LLU: // 99999999AU'''''''''''''''
66863	67475	{
66864		- state.addr = 18446744073709547646LLU; // 99999999A8'''''''''''''''
	67476	+ state.addr = 18446744073709547606LLU; // 99999999AV'''''''''''''''
66865	67477	break;
66866	67478	}
66867		- case 18446744073709547646LLU: // 99999999A8'''''''''''''''
	67479	+ case 18446744073709547606LLU: // 99999999AV'''''''''''''''
66868	67480	{
66869	67481	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 18LLU, 7LLU)));
66870	67482	fprintf(stdout, "%s", "\n --");

		@@ -66878,7 +67490,7 @@
66878	67490	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66879	67491	}
66880	67492	// ACCUMULATE ARGUMENTS - END
66881		- uint64_t return_to = 18446744073709547642LLU;
	67493	+ uint64_t return_to = 18446744073709547602LLU;
66882	67494	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
66883	67495	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66884	67496	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66887,12 +67499,12 @@
66887	67499	state.addr = 839519719621918720LLU; // skipws____
66888	67500	break;
66889	67501	}
66890		- case 18446744073709547642LLU: // 99999999A4'''''''''''''''
	67502	+ case 18446744073709547602LLU: // 99999999AR'''''''''''''''
66891	67503	{
66892		- state.addr = 18446744073709547643LLU; // 99999999A5'''''''''''''''
	67504	+ state.addr = 18446744073709547603LLU; // 99999999AS'''''''''''''''
66893	67505	break;
66894	67506	}
66895		- case 18446744073709547643LLU: // 99999999A5'''''''''''''''
	67507	+ case 18446744073709547603LLU: // 99999999AS'''''''''''''''
66896	67508	{
66897	67509	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
66898	67510	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -66913,7 +67525,7 @@
66913	67525	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
66914	67526	}
66915	67527	// ACCUMULATE ARGUMENTS - END
66916		- uint64_t return_to = 18446744073709547640LLU;
	67528	+ uint64_t return_to = 18446744073709547600LLU;
66917	67529	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
66918	67530	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
66919	67531	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -66922,12 +67534,12 @@
66922	67534	state.addr = 517555565473470767LLU; // assertinit
66923	67535	break;
66924	67536	}
66925		- case 18446744073709547640LLU: // 99999999A2'''''''''''''''
	67537	+ case 18446744073709547600LLU: // 99999999AP'''''''''''''''
66926	67538	{
66927		- state.addr = 18446744073709547641LLU; // 99999999A3'''''''''''''''
	67539	+ state.addr = 18446744073709547601LLU; // 99999999AQ'''''''''''''''
66928	67540	break;
66929	67541	}
66930		- case 18446744073709547641LLU: // 99999999A3'''''''''''''''
	67542	+ case 18446744073709547601LLU: // 99999999AQ'''''''''''''''
66931	67543	{
66932	67544	{
66933	67545	uint64_t arg = 0LLU;

		@@ -67003,7 +67615,7 @@
67003	67615	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67004	67616	}
67005	67617	// ACCUMULATE ARGUMENTS - END
67006		- uint64_t return_to = 18446744073709547638LLU;
	67618	+ uint64_t return_to = 18446744073709547598LLU;
67007	67619	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
67008	67620	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67009	67621	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67012,12 +67624,12 @@
67012	67624	state.addr = 787472342492567585LLU; // procvarref
67013	67625	break;
67014	67626	}
67015		- case 18446744073709547638LLU: // 99999999A0'''''''''''''''
	67627	+ case 18446744073709547598LLU: // 99999999AN'''''''''''''''
67016	67628	{
67017		- state.addr = 18446744073709547639LLU; // 99999999A1'''''''''''''''
	67629	+ state.addr = 18446744073709547599LLU; // 99999999AO'''''''''''''''
67018	67630	break;
67019	67631	}
67020		- case 18446744073709547639LLU: // 99999999A1'''''''''''''''
	67632	+ case 18446744073709547599LLU: // 99999999AO'''''''''''''''
67021	67633	{
67022	67634	// variable u64 initialize goes out of scope
67023	67635	// emitted destructur for type u64

		@@ -67028,10 +67640,10 @@
67028	67640	// variable u64 idx_______ goes out of scope
67029	67641	// emitted destructur for type u64
67030	67642	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
67031		- state.addr = 18446744073709547644LLU; // 99999999A6'''''''''''''''
	67643	+ state.addr = 18446744073709547604LLU; // 99999999AT'''''''''''''''
67032	67644	break;
67033	67645	}
67034		- case 18446744073709547644LLU: // 99999999A6'''''''''''''''
	67646	+ case 18446744073709547604LLU: // 99999999AT'''''''''''''''
67035	67647	{
67036	67648	fprintf(stdout, "%s", ";");
67037	67649	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67040,7 +67652,7 @@
67040	67652	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67041	67653	}
67042	67654	// ACCUMULATE ARGUMENTS - END
67043		- uint64_t return_to = 18446744073709547636LLU;
	67655	+ uint64_t return_to = 18446744073709547596LLU;
67044	67656	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67045	67657	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67046	67658	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67049,12 +67661,12 @@
67049	67661	state.addr = 839519719621918720LLU; // skipws____
67050	67662	break;
67051	67663	}
67052		- case 18446744073709547636LLU: // 99999999Ay'''''''''''''''
	67664	+ case 18446744073709547596LLU: // 99999999AL'''''''''''''''
67053	67665	{
67054		- state.addr = 18446744073709547637LLU; // 99999999Az'''''''''''''''
	67666	+ state.addr = 18446744073709547597LLU; // 99999999AM'''''''''''''''
67055	67667	break;
67056	67668	}
67057		- case 18446744073709547637LLU: // 99999999Az'''''''''''''''
	67669	+ case 18446744073709547597LLU: // 99999999AM'''''''''''''''
67058	67670	{
67059	67671	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
67060	67672	if(')' != (char)getchar())

		@@ -67072,7 +67684,7 @@
67072	67684	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67073	67685	}
67074	67686	// ACCUMULATE ARGUMENTS - END
67075		- uint64_t return_to = 18446744073709547634LLU;
	67687	+ uint64_t return_to = 18446744073709547594LLU;
67076	67688	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
67077	67689	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67078	67690	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67081,12 +67693,12 @@
67081	67693	state.addr = 517555565476695680LLU; // assertu64_
67082	67694	break;
67083	67695	}
67084		- case 18446744073709547634LLU: // 99999999Aw'''''''''''''''
	67696	+ case 18446744073709547594LLU: // 99999999AJ'''''''''''''''
67085	67697	{
67086		- state.addr = 18446744073709547635LLU; // 99999999Ax'''''''''''''''
	67698	+ state.addr = 18446744073709547595LLU; // 99999999AK'''''''''''''''
67087	67699	break;
67088	67700	}
67089		- case 18446744073709547635LLU: // 99999999Ax'''''''''''''''
	67701	+ case 18446744073709547595LLU: // 99999999AK'''''''''''''''
67090	67702	{
67091	67703	{
67092	67704	uint64_t arg = 1LLU;

		@@ -67114,7 +67726,7 @@
67114	67726	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67115	67727	}
67116	67728	// ACCUMULATE ARGUMENTS - END
67117		- uint64_t return_to = 18446744073709547631LLU;
	67729	+ uint64_t return_to = 18446744073709547591LLU;
67118	67730	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
67119	67731	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67120	67732	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67123,20 +67735,20 @@
67123	67735	state.addr = 734295421765213120LLU; // mutassert_
67124	67736	break;
67125	67737	}
67126		- case 18446744073709547631LLU: // 99999999At'''''''''''''''
	67738	+ case 18446744073709547591LLU: // 99999999AG'''''''''''''''
67127	67739	{
67128		- state.addr = 18446744073709547632LLU; // 99999999Au'''''''''''''''
	67740	+ state.addr = 18446744073709547592LLU; // 99999999AH'''''''''''''''
67129	67741	break;
67130	67742	}
67131		- case 18446744073709547632LLU: // 99999999Au'''''''''''''''
	67743	+ case 18446744073709547592LLU: // 99999999AH'''''''''''''''
67132	67744	{
67133	67745	// variable u64 parnr_____ goes out of scope
67134	67746	// emitted destructur for type u64
67135	67747	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
67136		- state.addr = 18446744073709547633LLU; // 99999999Av'''''''''''''''
	67748	+ state.addr = 18446744073709547593LLU; // 99999999AI'''''''''''''''
67137	67749	break;
67138	67750	}
67139		- case 18446744073709547633LLU: // 99999999Av'''''''''''''''
	67751	+ case 18446744073709547593LLU: // 99999999AI'''''''''''''''
67140	67752	{
67141	67753	// variable u64 mutable___ goes out of scope
67142	67754	// emitted destructur for type u64

		@@ -67149,7 +67761,7 @@
67149	67761	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67150	67762	}
67151	67763	// ACCUMULATE ARGUMENTS - END
67152		- uint64_t return_to = 18446744073709547630LLU;
	67764	+ uint64_t return_to = 18446744073709547590LLU;
67153	67765	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67154	67766	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67155	67767	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67158,7 +67770,7 @@
67158	67770	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
67159	67771	break;
67160	67772	}
67161		- case 18446744073709547630LLU: // 99999999As'''''''''''''''
	67773	+ case 18446744073709547590LLU: // 99999999AF'''''''''''''''
67162	67774	{
67163	67775	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 18
67164	67776	// variable u64 INDIRECT__ goes out of scope

		@@ -67169,50 +67781,50 @@
67169	67781	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
67170	67782	heap.availilable_size_for_dynamic_objects += 0LLU;
67171	67783	heap.availilable_size_for_dynamic_objects += 0LLU;
67172		- state.addr = 18446744073709547629LLU; // 99999999Ar'''''''''''''''
	67784	+ state.addr = 18446744073709547589LLU; // 99999999AE'''''''''''''''
67173	67785	break;
67174	67786	}
67175		- case 18446744073709547649LLU: // 99999999BA'''''''''''''''
	67787	+ case 18446744073709547609LLU: // 99999999AY'''''''''''''''
67176	67788	{
67177		- state.addr = 18446744073709547629LLU; // 99999999Ar'''''''''''''''
	67789	+ state.addr = 18446744073709547589LLU; // 99999999AE'''''''''''''''
67178	67790	break;
67179	67791	}
67180		- case 18446744073709547629LLU: // 99999999Ar'''''''''''''''
	67792	+ case 18446744073709547589LLU: // 99999999AE'''''''''''''''
67181	67793	{
67182		- state.addr = 18446744073709547651LLU; // 99999999BC'''''''''''''''
	67794	+ state.addr = 18446744073709547611LLU; // 99999999A$'''''''''''''''
67183	67795	break;
67184	67796	}
67185		- case 18446744073709547651LLU: // 99999999BC'''''''''''''''
	67797	+ case 18446744073709547611LLU: // 99999999A$'''''''''''''''
67186	67798	{
67187		- state.addr = 18446744073709547673LLU; // 99999999BY'''''''''''''''
	67799	+ state.addr = 18446744073709547633LLU; // 99999999Av'''''''''''''''
67188	67800	break;
67189	67801	}
67190		- case 18446744073709547673LLU: // 99999999BY'''''''''''''''
	67802	+ case 18446744073709547633LLU: // 99999999Av'''''''''''''''
67191	67803	{
67192		- state.addr = 18446744073709547692LLU; // 99999999Bq'''''''''''''''
	67804	+ state.addr = 18446744073709547652LLU; // 99999999BD'''''''''''''''
67193	67805	break;
67194	67806	}
67195		- case 18446744073709547692LLU: // 99999999Bq'''''''''''''''
	67807	+ case 18446744073709547652LLU: // 99999999BD'''''''''''''''
67196	67808	{
67197		- state.addr = 18446744073709547711LLU; // 99999999B9'''''''''''''''
	67809	+ state.addr = 18446744073709547671LLU; // 99999999BW'''''''''''''''
67198	67810	break;
67199	67811	}
67200		- case 18446744073709547711LLU: // 99999999B9'''''''''''''''
	67812	+ case 18446744073709547671LLU: // 99999999BW'''''''''''''''
67201	67813	{
67202		- state.addr = 18446744073709547733LLU; // 99999999CU'''''''''''''''
	67814	+ state.addr = 18446744073709547693LLU; // 99999999Br'''''''''''''''
67203	67815	break;
67204	67816	}
67205		- case 18446744073709547733LLU: // 99999999CU'''''''''''''''
	67817	+ case 18446744073709547693LLU: // 99999999Br'''''''''''''''
67206	67818	{
67207		- state.addr = 18446744073709547755LLU; // 99999999Cp'''''''''''''''
	67819	+ state.addr = 18446744073709547715LLU; // 99999999CC'''''''''''''''
67208	67820	break;
67209	67821	}
67210		- case 18446744073709547755LLU: // 99999999Cp'''''''''''''''
	67822	+ case 18446744073709547715LLU: // 99999999CC'''''''''''''''
67211	67823	{
67212		- state.addr = 18446744073709547774LLU; // 99999999C8'''''''''''''''
	67824	+ state.addr = 18446744073709547734LLU; // 99999999CV'''''''''''''''
67213	67825	break;
67214	67826	}
67215		- case 18446744073709547774LLU: // 99999999C8'''''''''''''''
	67827	+ case 18446744073709547734LLU: // 99999999CV'''''''''''''''
67216	67828	{
67217	67829	// variable u64 sym_______ goes out of scope
67218	67830	// emitted destructur for type u64

		@@ -67262,10 +67874,10 @@
67262	67874	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 532757408862961664LLU;
67263	67875
67264	67876	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
67265		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547628LLU : 18446744073709547627LLU;
	67877	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547588LLU : 18446744073709547587LLU;
67266	67878	break;
67267	67879	}
67268		- case 18446744073709547628LLU: // 99999999Aq'''''''''''''''
	67880	+ case 18446744073709547588LLU: // 99999999AD'''''''''''''''
67269	67881	{
67270	67882	{
67271	67883	uint64_t arg = 0LLU;

		@@ -67289,7 +67901,7 @@
67289	67901	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67290	67902	}
67291	67903	// ACCUMULATE ARGUMENTS - END
67292		- uint64_t return_to = 18446744073709547625LLU;
	67904	+ uint64_t return_to = 18446744073709547585LLU;
67293	67905	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67294	67906	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67295	67907	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67298,12 +67910,12 @@
67298	67910	state.addr = 861504796319285248LLU; // typeu64___
67299	67911	break;
67300	67912	}
67301		- case 18446744073709547625LLU: // 99999999An'''''''''''''''
	67913	+ case 18446744073709547585LLU: // 99999999AA'''''''''''''''
67302	67914	{
67303		- state.addr = 18446744073709547626LLU; // 99999999Ao'''''''''''''''
	67915	+ state.addr = 18446744073709547586LLU; // 99999999AB'''''''''''''''
67304	67916	break;
67305	67917	}
67306		- case 18446744073709547626LLU: // 99999999Ao'''''''''''''''
	67918	+ case 18446744073709547586LLU: // 99999999AB'''''''''''''''
67307	67919	{
67308	67920	// ACCUMULATE ARGUMENTS - BEGIN
67309	67921	{

		@@ -67311,7 +67923,7 @@
67311	67923	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67312	67924	}
67313	67925	// ACCUMULATE ARGUMENTS - END
67314		- uint64_t return_to = 18446744073709547623LLU;
	67926	+ uint64_t return_to = 18446744073709547583LLU;
67315	67927	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67316	67928	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67317	67929	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67320,12 +67932,12 @@
67320	67932	state.addr = 839519719621918720LLU; // skipws____
67321	67933	break;
67322	67934	}
67323		- case 18446744073709547623LLU: // 99999999Al'''''''''''''''
	67935	+ case 18446744073709547583LLU: // 99999999_9'''''''''''''''
67324	67936	{
67325		- state.addr = 18446744073709547624LLU; // 99999999Am'''''''''''''''
	67937	+ state.addr = 18446744073709547584LLU; // 99999999A_'''''''''''''''
67326	67938	break;
67327	67939	}
67328		- case 18446744073709547624LLU: // 99999999Am'''''''''''''''
	67940	+ case 18446744073709547584LLU: // 99999999A_'''''''''''''''
67329	67941	{
67330	67942	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67331	67943	fprintf(stdout, "%s", "\n ");

		@@ -67335,7 +67947,7 @@
67335	67947	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67336	67948	}
67337	67949	// ACCUMULATE ARGUMENTS - END
67338		- uint64_t return_to = 18446744073709547619LLU;
	67950	+ uint64_t return_to = 18446744073709547579LLU;
67339	67951	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67340	67952	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67341	67953	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67344,12 +67956,12 @@
67344	67956	state.addr = 839519719621918720LLU; // skipws____
67345	67957	break;
67346	67958	}
67347		- case 18446744073709547619LLU: // 99999999Ah'''''''''''''''
	67959	+ case 18446744073709547579LLU: // 99999999_5'''''''''''''''
67348	67960	{
67349		- state.addr = 18446744073709547620LLU; // 99999999Ai'''''''''''''''
	67961	+ state.addr = 18446744073709547580LLU; // 99999999_6'''''''''''''''
67350	67962	break;
67351	67963	}
67352		- case 18446744073709547620LLU: // 99999999Ai'''''''''''''''
	67964	+ case 18446744073709547580LLU: // 99999999_6'''''''''''''''
67353	67965	{
67354	67966	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67355	67967	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67370,7 +67982,7 @@
67370	67982	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67371	67983	}
67372	67984	// ACCUMULATE ARGUMENTS - END
67373		- uint64_t return_to = 18446744073709547617LLU;
	67985	+ uint64_t return_to = 18446744073709547577LLU;
67374	67986	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
67375	67987	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67376	67988	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67379,12 +67991,12 @@
67379	67991	state.addr = 517555565473470767LLU; // assertinit
67380	67992	break;
67381	67993	}
67382		- case 18446744073709547617LLU: // 99999999Af'''''''''''''''
	67994	+ case 18446744073709547577LLU: // 99999999_3'''''''''''''''
67383	67995	{
67384		- state.addr = 18446744073709547618LLU; // 99999999Ag'''''''''''''''
	67996	+ state.addr = 18446744073709547578LLU; // 99999999_4'''''''''''''''
67385	67997	break;
67386	67998	}
67387		- case 18446744073709547618LLU: // 99999999Ag'''''''''''''''
	67999	+ case 18446744073709547578LLU: // 99999999_4'''''''''''''''
67388	68000	{
67389	68001	{
67390	68002	uint64_t arg = 0LLU;

		@@ -67460,7 +68072,7 @@
67460	68072	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67461	68073	}
67462	68074	// ACCUMULATE ARGUMENTS - END
67463		- uint64_t return_to = 18446744073709547615LLU;
	68075	+ uint64_t return_to = 18446744073709547575LLU;
67464	68076	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
67465	68077	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67466	68078	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67469,12 +68081,12 @@
67469	68081	state.addr = 787472342492567585LLU; // procvarref
67470	68082	break;
67471	68083	}
67472		- case 18446744073709547615LLU: // 99999999Ad'''''''''''''''
	68084	+ case 18446744073709547575LLU: // 99999999_1'''''''''''''''
67473	68085	{
67474		- state.addr = 18446744073709547616LLU; // 99999999Ae'''''''''''''''
	68086	+ state.addr = 18446744073709547576LLU; // 99999999_2'''''''''''''''
67475	68087	break;
67476	68088	}
67477		- case 18446744073709547616LLU: // 99999999Ae'''''''''''''''
	68089	+ case 18446744073709547576LLU: // 99999999_2'''''''''''''''
67478	68090	{
67479	68091	// variable u64 initialize goes out of scope
67480	68092	// emitted destructur for type u64

		@@ -67485,10 +68097,10 @@
67485	68097	// variable u64 idx_______ goes out of scope
67486	68098	// emitted destructur for type u64
67487	68099	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
67488		- state.addr = 18446744073709547621LLU; // 99999999Aj'''''''''''''''
	68100	+ state.addr = 18446744073709547581LLU; // 99999999_7'''''''''''''''
67489	68101	break;
67490	68102	}
67491		- case 18446744073709547621LLU: // 99999999Aj'''''''''''''''
	68103	+ case 18446744073709547581LLU: // 99999999_7'''''''''''''''
67492	68104	{
67493	68105	// ACCUMULATE ARGUMENTS - BEGIN
67494	68106	{

		@@ -67500,7 +68112,7 @@
67500	68112	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67501	68113	}
67502	68114	// ACCUMULATE ARGUMENTS - END
67503		- uint64_t return_to = 18446744073709547613LLU;
	68115	+ uint64_t return_to = 18446744073709547573LLU;
67504	68116	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
67505	68117	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67506	68118	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67509,12 +68121,12 @@
67509	68121	state.addr = 517555565476695680LLU; // assertu64_
67510	68122	break;
67511	68123	}
67512		- case 18446744073709547613LLU: // 99999999Ab'''''''''''''''
	68124	+ case 18446744073709547573LLU: // 99999999_z'''''''''''''''
67513	68125	{
67514		- state.addr = 18446744073709547614LLU; // 99999999Ac'''''''''''''''
	68126	+ state.addr = 18446744073709547574LLU; // 99999999_0'''''''''''''''
67515	68127	break;
67516	68128	}
67517		- case 18446744073709547614LLU: // 99999999Ac'''''''''''''''
	68129	+ case 18446744073709547574LLU: // 99999999_0'''''''''''''''
67518	68130	{
67519	68131	{
67520	68132	uint64_t arg = 1LLU;

		@@ -67542,7 +68154,7 @@
67542	68154	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67543	68155	}
67544	68156	// ACCUMULATE ARGUMENTS - END
67545		- uint64_t return_to = 18446744073709547610LLU;
	68157	+ uint64_t return_to = 18446744073709547570LLU;
67546	68158	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
67547	68159	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67548	68160	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67551,25 +68163,25 @@
67551	68163	state.addr = 734295421765213120LLU; // mutassert_
67552	68164	break;
67553	68165	}
67554		- case 18446744073709547610LLU: // 99999999AZ'''''''''''''''
	68166	+ case 18446744073709547570LLU: // 99999999_w'''''''''''''''
67555	68167	{
67556		- state.addr = 18446744073709547611LLU; // 99999999A$'''''''''''''''
	68168	+ state.addr = 18446744073709547571LLU; // 99999999_x'''''''''''''''
67557	68169	break;
67558	68170	}
67559		- case 18446744073709547611LLU: // 99999999A$'''''''''''''''
	68171	+ case 18446744073709547571LLU: // 99999999_x'''''''''''''''
67560	68172	{
67561	68173	// variable u64 parnr_____ goes out of scope
67562	68174	// emitted destructur for type u64
67563	68175	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
67564		- state.addr = 18446744073709547612LLU; // 99999999Aa'''''''''''''''
	68176	+ state.addr = 18446744073709547572LLU; // 99999999_y'''''''''''''''
67565	68177	break;
67566	68178	}
67567		- case 18446744073709547612LLU: // 99999999Aa'''''''''''''''
	68179	+ case 18446744073709547572LLU: // 99999999_y'''''''''''''''
67568	68180	{
67569		- state.addr = 18446744073709547622LLU; // 99999999Ak'''''''''''''''
	68181	+ state.addr = 18446744073709547582LLU; // 99999999_8'''''''''''''''
67570	68182	break;
67571	68183	}
67572		- case 18446744073709547622LLU: // 99999999Ak'''''''''''''''
	68184	+ case 18446744073709547582LLU: // 99999999_8'''''''''''''''
67573	68185	{
67574	68186	// ACCUMULATE ARGUMENTS - BEGIN
67575	68187	{

		@@ -67577,7 +68189,7 @@
67577	68189	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67578	68190	}
67579	68191	// ACCUMULATE ARGUMENTS - END
67580		- uint64_t return_to = 18446744073709547608LLU;
	68192	+ uint64_t return_to = 18446744073709547568LLU;
67581	68193	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67582	68194	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67583	68195	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67586,12 +68198,12 @@
67586	68198	state.addr = 839519719621918720LLU; // skipws____
67587	68199	break;
67588	68200	}
67589		- case 18446744073709547608LLU: // 99999999AX'''''''''''''''
	68201	+ case 18446744073709547568LLU: // 99999999_u'''''''''''''''
67590	68202	{
67591		- state.addr = 18446744073709547609LLU; // 99999999AY'''''''''''''''
	68203	+ state.addr = 18446744073709547569LLU; // 99999999_v'''''''''''''''
67592	68204	break;
67593	68205	}
67594		- case 18446744073709547609LLU: // 99999999AY'''''''''''''''
	68206	+ case 18446744073709547569LLU: // 99999999_v'''''''''''''''
67595	68207	{
67596	68208	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67597	68209	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67600,7 +68212,7 @@
67600	68212	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67601	68213	}
67602	68214	// ACCUMULATE ARGUMENTS - END
67603		- uint64_t return_to = 18446744073709547606LLU;
	68215	+ uint64_t return_to = 18446744073709547566LLU;
67604	68216	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67605	68217	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67606	68218	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67609,12 +68221,12 @@
67609	68221	state.addr = 839519719621918720LLU; // skipws____
67610	68222	break;
67611	68223	}
67612		- case 18446744073709547606LLU: // 99999999AV'''''''''''''''
	68224	+ case 18446744073709547566LLU: // 99999999_s'''''''''''''''
67613	68225	{
67614		- state.addr = 18446744073709547607LLU; // 99999999AW'''''''''''''''
	68226	+ state.addr = 18446744073709547567LLU; // 99999999_t'''''''''''''''
67615	68227	break;
67616	68228	}
67617		- case 18446744073709547607LLU: // 99999999AW'''''''''''''''
	68229	+ case 18446744073709547567LLU: // 99999999_t'''''''''''''''
67618	68230	{
67619	68231	fprintf(stdout, "%s", " = ~");
67620	68232	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67623,7 +68235,7 @@
67623	68235	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67624	68236	}
67625	68237	// ACCUMULATE ARGUMENTS - END
67626		- uint64_t return_to = 18446744073709547602LLU;
	68238	+ uint64_t return_to = 18446744073709547562LLU;
67627	68239	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67628	68240	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67629	68241	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67632,12 +68244,12 @@
67632	68244	state.addr = 839519719621918720LLU; // skipws____
67633	68245	break;
67634	68246	}
67635		- case 18446744073709547602LLU: // 99999999AR'''''''''''''''
	68247	+ case 18446744073709547562LLU: // 99999999_o'''''''''''''''
67636	68248	{
67637		- state.addr = 18446744073709547603LLU; // 99999999AS'''''''''''''''
	68249	+ state.addr = 18446744073709547563LLU; // 99999999_p'''''''''''''''
67638	68250	break;
67639	68251	}
67640		- case 18446744073709547603LLU: // 99999999AS'''''''''''''''
	68252	+ case 18446744073709547563LLU: // 99999999_p'''''''''''''''
67641	68253	{
67642	68254	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67643	68255	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67658,7 +68270,7 @@
67658	68270	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67659	68271	}
67660	68272	// ACCUMULATE ARGUMENTS - END
67661		- uint64_t return_to = 18446744073709547600LLU;
	68273	+ uint64_t return_to = 18446744073709547560LLU;
67662	68274	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
67663	68275	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67664	68276	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67667,12 +68279,12 @@
67667	68279	state.addr = 517555565473470767LLU; // assertinit
67668	68280	break;
67669	68281	}
67670		- case 18446744073709547600LLU: // 99999999AP'''''''''''''''
	68282	+ case 18446744073709547560LLU: // 99999999_m'''''''''''''''
67671	68283	{
67672		- state.addr = 18446744073709547601LLU; // 99999999AQ'''''''''''''''
	68284	+ state.addr = 18446744073709547561LLU; // 99999999_n'''''''''''''''
67673	68285	break;
67674	68286	}
67675		- case 18446744073709547601LLU: // 99999999AQ'''''''''''''''
	68287	+ case 18446744073709547561LLU: // 99999999_n'''''''''''''''
67676	68288	{
67677	68289	{
67678	68290	uint64_t arg = 0LLU;

		@@ -67748,7 +68360,7 @@
67748	68360	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67749	68361	}
67750	68362	// ACCUMULATE ARGUMENTS - END
67751		- uint64_t return_to = 18446744073709547598LLU;
	68363	+ uint64_t return_to = 18446744073709547558LLU;
67752	68364	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
67753	68365	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67754	68366	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67757,12 +68369,12 @@
67757	68369	state.addr = 787472342492567585LLU; // procvarref
67758	68370	break;
67759	68371	}
67760		- case 18446744073709547598LLU: // 99999999AN'''''''''''''''
	68372	+ case 18446744073709547558LLU: // 99999999_k'''''''''''''''
67761	68373	{
67762		- state.addr = 18446744073709547599LLU; // 99999999AO'''''''''''''''
	68374	+ state.addr = 18446744073709547559LLU; // 99999999_l'''''''''''''''
67763	68375	break;
67764	68376	}
67765		- case 18446744073709547599LLU: // 99999999AO'''''''''''''''
	68377	+ case 18446744073709547559LLU: // 99999999_l'''''''''''''''
67766	68378	{
67767	68379	// variable u64 initialize goes out of scope
67768	68380	// emitted destructur for type u64

		@@ -67773,10 +68385,10 @@
67773	68385	// variable u64 idx_______ goes out of scope
67774	68386	// emitted destructur for type u64
67775	68387	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
67776		- state.addr = 18446744073709547604LLU; // 99999999AT'''''''''''''''
	68388	+ state.addr = 18446744073709547564LLU; // 99999999_q'''''''''''''''
67777	68389	break;
67778	68390	}
67779		- case 18446744073709547604LLU: // 99999999AT'''''''''''''''
	68391	+ case 18446744073709547564LLU: // 99999999_q'''''''''''''''
67780	68392	{
67781	68393	// ACCUMULATE ARGUMENTS - BEGIN
67782	68394	{

		@@ -67788,7 +68400,7 @@
67788	68400	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67789	68401	}
67790	68402	// ACCUMULATE ARGUMENTS - END
67791		- uint64_t return_to = 18446744073709547596LLU;
	68403	+ uint64_t return_to = 18446744073709547556LLU;
67792	68404	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
67793	68405	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67794	68406	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67797,17 +68409,17 @@
67797	68409	state.addr = 517555565476695680LLU; // assertu64_
67798	68410	break;
67799	68411	}
67800		- case 18446744073709547596LLU: // 99999999AL'''''''''''''''
	68412	+ case 18446744073709547556LLU: // 99999999_i'''''''''''''''
67801	68413	{
67802		- state.addr = 18446744073709547597LLU; // 99999999AM'''''''''''''''
	68414	+ state.addr = 18446744073709547557LLU; // 99999999_j'''''''''''''''
67803	68415	break;
67804	68416	}
67805		- case 18446744073709547597LLU: // 99999999AM'''''''''''''''
	68417	+ case 18446744073709547557LLU: // 99999999_j'''''''''''''''
67806	68418	{
67807		- state.addr = 18446744073709547605LLU; // 99999999AU'''''''''''''''
	68419	+ state.addr = 18446744073709547565LLU; // 99999999_r'''''''''''''''
67808	68420	break;
67809	68421	}
67810		- case 18446744073709547605LLU: // 99999999AU'''''''''''''''
	68422	+ case 18446744073709547565LLU: // 99999999_r'''''''''''''''
67811	68423	{
67812	68424	// ACCUMULATE ARGUMENTS - BEGIN
67813	68425	{

		@@ -67815,7 +68427,7 @@
67815	68427	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67816	68428	}
67817	68429	// ACCUMULATE ARGUMENTS - END
67818		- uint64_t return_to = 18446744073709547594LLU;
	68430	+ uint64_t return_to = 18446744073709547554LLU;
67819	68431	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67820	68432	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67821	68433	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67824,12 +68436,12 @@
67824	68436	state.addr = 839519719621918720LLU; // skipws____
67825	68437	break;
67826	68438	}
67827		- case 18446744073709547594LLU: // 99999999AJ'''''''''''''''
	68439	+ case 18446744073709547554LLU: // 99999999_g'''''''''''''''
67828	68440	{
67829		- state.addr = 18446744073709547595LLU; // 99999999AK'''''''''''''''
	68441	+ state.addr = 18446744073709547555LLU; // 99999999_h'''''''''''''''
67830	68442	break;
67831	68443	}
67832		- case 18446744073709547595LLU: // 99999999AK'''''''''''''''
	68444	+ case 18446744073709547555LLU: // 99999999_h'''''''''''''''
67833	68445	{
67834	68446	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
67835	68447	if(')' != (char)getchar())

		@@ -67846,7 +68458,7 @@
67846	68458	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67847	68459	}
67848	68460	// ACCUMULATE ARGUMENTS - END
67849		- uint64_t return_to = 18446744073709547593LLU;
	68461	+ uint64_t return_to = 18446744073709547553LLU;
67850	68462	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67851	68463	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67852	68464	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67855,7 +68467,7 @@
67855	68467	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
67856	68468	break;
67857	68469	}
67858		- case 18446744073709547593LLU: // 99999999AI'''''''''''''''
	68470	+ case 18446744073709547553LLU: // 99999999_f'''''''''''''''
67859	68471	{
67860	68472	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 19
67861	68473	// variable u64 mutable___ goes out of scope

		@@ -67869,18 +68481,18 @@
67869	68481	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
67870	68482	heap.availilable_size_for_dynamic_objects += 0LLU;
67871	68483	heap.availilable_size_for_dynamic_objects += 0LLU;
67872		- state.addr = 18446744073709547592LLU; // 99999999AH'''''''''''''''
	68484	+ state.addr = 18446744073709547552LLU; // 99999999_e'''''''''''''''
67873	68485	break;
67874	68486	}
67875		- case 18446744073709547627LLU: // 99999999Ap'''''''''''''''
	68487	+ case 18446744073709547587LLU: // 99999999AC'''''''''''''''
67876	68488	{
67877	68489	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 750618996096630784LLU;
67878	68490
67879	68491	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
67880		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547591LLU : 18446744073709547590LLU;
	68492	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547551LLU : 18446744073709547550LLU;
67881	68493	break;
67882	68494	}
67883		- case 18446744073709547591LLU: // 99999999AG'''''''''''''''
	68495	+ case 18446744073709547551LLU: // 99999999_d'''''''''''''''
67884	68496	{
67885	68497	{
67886	68498	uint64_t arg = 0LLU;

		@@ -67904,7 +68516,7 @@
67904	68516	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67905	68517	}
67906	68518	// ACCUMULATE ARGUMENTS - END
67907		- uint64_t return_to = 18446744073709547588LLU;
	68519	+ uint64_t return_to = 18446744073709547548LLU;
67908	68520	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67909	68521	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67910	68522	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67913,12 +68525,12 @@
67913	68525	state.addr = 861504796319285248LLU; // typeu64___
67914	68526	break;
67915	68527	}
67916		- case 18446744073709547588LLU: // 99999999AD'''''''''''''''
	68528	+ case 18446744073709547548LLU: // 99999999_a'''''''''''''''
67917	68529	{
67918		- state.addr = 18446744073709547589LLU; // 99999999AE'''''''''''''''
	68530	+ state.addr = 18446744073709547549LLU; // 99999999_b'''''''''''''''
67919	68531	break;
67920	68532	}
67921		- case 18446744073709547589LLU: // 99999999AE'''''''''''''''
	68533	+ case 18446744073709547549LLU: // 99999999_b'''''''''''''''
67922	68534	{
67923	68535	// ACCUMULATE ARGUMENTS - BEGIN
67924	68536	{

		@@ -67926,7 +68538,7 @@
67926	68538	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67927	68539	}
67928	68540	// ACCUMULATE ARGUMENTS - END
67929		- uint64_t return_to = 18446744073709547586LLU;
	68541	+ uint64_t return_to = 18446744073709547546LLU;
67930	68542	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67931	68543	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67932	68544	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67935,12 +68547,12 @@
67935	68547	state.addr = 839519719621918720LLU; // skipws____
67936	68548	break;
67937	68549	}
67938		- case 18446744073709547586LLU: // 99999999AB'''''''''''''''
	68550	+ case 18446744073709547546LLU: // 99999999_Z'''''''''''''''
67939	68551	{
67940		- state.addr = 18446744073709547587LLU; // 99999999AC'''''''''''''''
	68552	+ state.addr = 18446744073709547547LLU; // 99999999_$'''''''''''''''
67941	68553	break;
67942	68554	}
67943		- case 18446744073709547587LLU: // 99999999AC'''''''''''''''
	68555	+ case 18446744073709547547LLU: // 99999999_$'''''''''''''''
67944	68556	{
67945	68557	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67946	68558	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67949,7 +68561,7 @@
67949	68561	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67950	68562	}
67951	68563	// ACCUMULATE ARGUMENTS - END
67952		- uint64_t return_to = 18446744073709547584LLU;
	68564	+ uint64_t return_to = 18446744073709547544LLU;
67953	68565	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67954	68566	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67955	68567	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67958,12 +68570,12 @@
67958	68570	state.addr = 839519719621918720LLU; // skipws____
67959	68571	break;
67960	68572	}
67961		- case 18446744073709547584LLU: // 99999999A_'''''''''''''''
	68573	+ case 18446744073709547544LLU: // 99999999_X'''''''''''''''
67962	68574	{
67963		- state.addr = 18446744073709547585LLU; // 99999999AA'''''''''''''''
	68575	+ state.addr = 18446744073709547545LLU; // 99999999_Y'''''''''''''''
67964	68576	break;
67965	68577	}
67966		- case 18446744073709547585LLU: // 99999999AA'''''''''''''''
	68578	+ case 18446744073709547545LLU: // 99999999_Y'''''''''''''''
67967	68579	{
67968	68580	fprintf(stdout, "%s", "\n ");
67969	68581	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -67972,7 +68584,7 @@
67972	68584	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
67973	68585	}
67974	68586	// ACCUMULATE ARGUMENTS - END
67975		- uint64_t return_to = 18446744073709547580LLU;
	68587	+ uint64_t return_to = 18446744073709547540LLU;
67976	68588	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
67977	68589	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
67978	68590	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -67981,12 +68593,12 @@
67981	68593	state.addr = 839519719621918720LLU; // skipws____
67982	68594	break;
67983	68595	}
67984		- case 18446744073709547580LLU: // 99999999_6'''''''''''''''
	68596	+ case 18446744073709547540LLU: // 99999999_T'''''''''''''''
67985	68597	{
67986		- state.addr = 18446744073709547581LLU; // 99999999_7'''''''''''''''
	68598	+ state.addr = 18446744073709547541LLU; // 99999999_U'''''''''''''''
67987	68599	break;
67988	68600	}
67989		- case 18446744073709547581LLU: // 99999999_7'''''''''''''''
	68601	+ case 18446744073709547541LLU: // 99999999_U'''''''''''''''
67990	68602	{
67991	68603	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
67992	68604	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68007,7 +68619,7 @@
68007	68619	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68008	68620	}
68009	68621	// ACCUMULATE ARGUMENTS - END
68010		- uint64_t return_to = 18446744073709547578LLU;
	68622	+ uint64_t return_to = 18446744073709547538LLU;
68011	68623	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
68012	68624	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68013	68625	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68016,12 +68628,12 @@
68016	68628	state.addr = 517555565473470767LLU; // assertinit
68017	68629	break;
68018	68630	}
68019		- case 18446744073709547578LLU: // 99999999_4'''''''''''''''
	68631	+ case 18446744073709547538LLU: // 99999999_R'''''''''''''''
68020	68632	{
68021		- state.addr = 18446744073709547579LLU; // 99999999_5'''''''''''''''
	68633	+ state.addr = 18446744073709547539LLU; // 99999999_S'''''''''''''''
68022	68634	break;
68023	68635	}
68024		- case 18446744073709547579LLU: // 99999999_5'''''''''''''''
	68636	+ case 18446744073709547539LLU: // 99999999_S'''''''''''''''
68025	68637	{
68026	68638	{
68027	68639	uint64_t arg = 0LLU;

		@@ -68097,7 +68709,7 @@
68097	68709	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68098	68710	}
68099	68711	// ACCUMULATE ARGUMENTS - END
68100		- uint64_t return_to = 18446744073709547576LLU;
	68712	+ uint64_t return_to = 18446744073709547536LLU;
68101	68713	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
68102	68714	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68103	68715	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68106,12 +68718,12 @@
68106	68718	state.addr = 787472342492567585LLU; // procvarref
68107	68719	break;
68108	68720	}
68109		- case 18446744073709547576LLU: // 99999999_2'''''''''''''''
	68721	+ case 18446744073709547536LLU: // 99999999_P'''''''''''''''
68110	68722	{
68111		- state.addr = 18446744073709547577LLU; // 99999999_3'''''''''''''''
	68723	+ state.addr = 18446744073709547537LLU; // 99999999_Q'''''''''''''''
68112	68724	break;
68113	68725	}
68114		- case 18446744073709547577LLU: // 99999999_3'''''''''''''''
	68726	+ case 18446744073709547537LLU: // 99999999_Q'''''''''''''''
68115	68727	{
68116	68728	// variable u64 initialize goes out of scope
68117	68729	// emitted destructur for type u64

		@@ -68122,10 +68734,10 @@
68122	68734	// variable u64 idx_______ goes out of scope
68123	68735	// emitted destructur for type u64
68124	68736	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
68125		- state.addr = 18446744073709547582LLU; // 99999999_8'''''''''''''''
	68737	+ state.addr = 18446744073709547542LLU; // 99999999_V'''''''''''''''
68126	68738	break;
68127	68739	}
68128		- case 18446744073709547582LLU: // 99999999_8'''''''''''''''
	68740	+ case 18446744073709547542LLU: // 99999999_V'''''''''''''''
68129	68741	{
68130	68742	// ACCUMULATE ARGUMENTS - BEGIN
68131	68743	{

		@@ -68137,7 +68749,7 @@
68137	68749	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68138	68750	}
68139	68751	// ACCUMULATE ARGUMENTS - END
68140		- uint64_t return_to = 18446744073709547574LLU;
	68752	+ uint64_t return_to = 18446744073709547534LLU;
68141	68753	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
68142	68754	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68143	68755	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68146,12 +68758,12 @@
68146	68758	state.addr = 517555565476695680LLU; // assertu64_
68147	68759	break;
68148	68760	}
68149		- case 18446744073709547574LLU: // 99999999_0'''''''''''''''
	68761	+ case 18446744073709547534LLU: // 99999999_N'''''''''''''''
68150	68762	{
68151		- state.addr = 18446744073709547575LLU; // 99999999_1'''''''''''''''
	68763	+ state.addr = 18446744073709547535LLU; // 99999999_O'''''''''''''''
68152	68764	break;
68153	68765	}
68154		- case 18446744073709547575LLU: // 99999999_1'''''''''''''''
	68766	+ case 18446744073709547535LLU: // 99999999_O'''''''''''''''
68155	68767	{
68156	68768	{
68157	68769	uint64_t arg = 1LLU;

		@@ -68179,7 +68791,7 @@
68179	68791	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68180	68792	}
68181	68793	// ACCUMULATE ARGUMENTS - END
68182		- uint64_t return_to = 18446744073709547571LLU;
	68794	+ uint64_t return_to = 18446744073709547531LLU;
68183	68795	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
68184	68796	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68185	68797	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68188,25 +68800,25 @@
68188	68800	state.addr = 734295421765213120LLU; // mutassert_
68189	68801	break;
68190	68802	}
68191		- case 18446744073709547571LLU: // 99999999_x'''''''''''''''
	68803	+ case 18446744073709547531LLU: // 99999999_K'''''''''''''''
68192	68804	{
68193		- state.addr = 18446744073709547572LLU; // 99999999_y'''''''''''''''
	68805	+ state.addr = 18446744073709547532LLU; // 99999999_L'''''''''''''''
68194	68806	break;
68195	68807	}
68196		- case 18446744073709547572LLU: // 99999999_y'''''''''''''''
	68808	+ case 18446744073709547532LLU: // 99999999_L'''''''''''''''
68197	68809	{
68198	68810	// variable u64 parnr_____ goes out of scope
68199	68811	// emitted destructur for type u64
68200	68812	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
68201		- state.addr = 18446744073709547573LLU; // 99999999_z'''''''''''''''
	68813	+ state.addr = 18446744073709547533LLU; // 99999999_M'''''''''''''''
68202	68814	break;
68203	68815	}
68204		- case 18446744073709547573LLU: // 99999999_z'''''''''''''''
	68816	+ case 18446744073709547533LLU: // 99999999_M'''''''''''''''
68205	68817	{
68206		- state.addr = 18446744073709547583LLU; // 99999999_9'''''''''''''''
	68818	+ state.addr = 18446744073709547543LLU; // 99999999_W'''''''''''''''
68207	68819	break;
68208	68820	}
68209		- case 18446744073709547583LLU: // 99999999_9'''''''''''''''
	68821	+ case 18446744073709547543LLU: // 99999999_W'''''''''''''''
68210	68822	{
68211	68823	// ACCUMULATE ARGUMENTS - BEGIN
68212	68824	{

		@@ -68214,7 +68826,7 @@
68214	68826	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68215	68827	}
68216	68828	// ACCUMULATE ARGUMENTS - END
68217		- uint64_t return_to = 18446744073709547569LLU;
	68829	+ uint64_t return_to = 18446744073709547529LLU;
68218	68830	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68219	68831	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68220	68832	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68223,12 +68835,12 @@
68223	68835	state.addr = 839519719621918720LLU; // skipws____
68224	68836	break;
68225	68837	}
68226		- case 18446744073709547569LLU: // 99999999_v'''''''''''''''
	68838	+ case 18446744073709547529LLU: // 99999999_I'''''''''''''''
68227	68839	{
68228		- state.addr = 18446744073709547570LLU; // 99999999_w'''''''''''''''
	68840	+ state.addr = 18446744073709547530LLU; // 99999999_J'''''''''''''''
68229	68841	break;
68230	68842	}
68231		- case 18446744073709547570LLU: // 99999999_w'''''''''''''''
	68843	+ case 18446744073709547530LLU: // 99999999_J'''''''''''''''
68232	68844	{
68233	68845	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68234	68846	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68237,7 +68849,7 @@
68237	68849	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68238	68850	}
68239	68851	// ACCUMULATE ARGUMENTS - END
68240		- uint64_t return_to = 18446744073709547567LLU;
	68852	+ uint64_t return_to = 18446744073709547527LLU;
68241	68853	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68242	68854	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68243	68855	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68246,12 +68858,12 @@
68246	68858	state.addr = 839519719621918720LLU; // skipws____
68247	68859	break;
68248	68860	}
68249		- case 18446744073709547567LLU: // 99999999_t'''''''''''''''
	68861	+ case 18446744073709547527LLU: // 99999999_G'''''''''''''''
68250	68862	{
68251		- state.addr = 18446744073709547568LLU; // 99999999_u'''''''''''''''
	68863	+ state.addr = 18446744073709547528LLU; // 99999999_H'''''''''''''''
68252	68864	break;
68253	68865	}
68254		- case 18446744073709547568LLU: // 99999999_u'''''''''''''''
	68866	+ case 18446744073709547528LLU: // 99999999_H'''''''''''''''
68255	68867	{
68256	68868	fprintf(stdout, "%s", " = !");
68257	68869	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68260,7 +68872,7 @@
68260	68872	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68261	68873	}
68262	68874	// ACCUMULATE ARGUMENTS - END
68263		- uint64_t return_to = 18446744073709547563LLU;
	68875	+ uint64_t return_to = 18446744073709547523LLU;
68264	68876	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68265	68877	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68266	68878	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68269,12 +68881,12 @@
68269	68881	state.addr = 839519719621918720LLU; // skipws____
68270	68882	break;
68271	68883	}
68272		- case 18446744073709547563LLU: // 99999999_p'''''''''''''''
	68884	+ case 18446744073709547523LLU: // 99999999_C'''''''''''''''
68273	68885	{
68274		- state.addr = 18446744073709547564LLU; // 99999999_q'''''''''''''''
	68886	+ state.addr = 18446744073709547524LLU; // 99999999_D'''''''''''''''
68275	68887	break;
68276	68888	}
68277		- case 18446744073709547564LLU: // 99999999_q'''''''''''''''
	68889	+ case 18446744073709547524LLU: // 99999999_D'''''''''''''''
68278	68890	{
68279	68891	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68280	68892	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68295,7 +68907,7 @@
68295	68907	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68296	68908	}
68297	68909	// ACCUMULATE ARGUMENTS - END
68298		- uint64_t return_to = 18446744073709547561LLU;
	68910	+ uint64_t return_to = 18446744073709547521LLU;
68299	68911	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
68300	68912	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68301	68913	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68304,12 +68916,12 @@
68304	68916	state.addr = 517555565473470767LLU; // assertinit
68305	68917	break;
68306	68918	}
68307		- case 18446744073709547561LLU: // 99999999_n'''''''''''''''
	68919	+ case 18446744073709547521LLU: // 99999999_A'''''''''''''''
68308	68920	{
68309		- state.addr = 18446744073709547562LLU; // 99999999_o'''''''''''''''
	68921	+ state.addr = 18446744073709547522LLU; // 99999999_B'''''''''''''''
68310	68922	break;
68311	68923	}
68312		- case 18446744073709547562LLU: // 99999999_o'''''''''''''''
	68924	+ case 18446744073709547522LLU: // 99999999_B'''''''''''''''
68313	68925	{
68314	68926	{
68315	68927	uint64_t arg = 0LLU;

		@@ -68385,7 +68997,7 @@
68385	68997	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68386	68998	}
68387	68999	// ACCUMULATE ARGUMENTS - END
68388		- uint64_t return_to = 18446744073709547559LLU;
	69000	+ uint64_t return_to = 18446744073709547519LLU;
68389	69001	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
68390	69002	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68391	69003	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68394,12 +69006,12 @@
68394	69006	state.addr = 787472342492567585LLU; // procvarref
68395	69007	break;
68396	69008	}
68397		- case 18446744073709547559LLU: // 99999999_l'''''''''''''''
	69009	+ case 18446744073709547519LLU: // 9999999899'''''''''''''''
68398	69010	{
68399		- state.addr = 18446744073709547560LLU; // 99999999_m'''''''''''''''
	69011	+ state.addr = 18446744073709547520LLU; // 99999999__'''''''''''''''
68400	69012	break;
68401	69013	}
68402		- case 18446744073709547560LLU: // 99999999_m'''''''''''''''
	69014	+ case 18446744073709547520LLU: // 99999999__'''''''''''''''
68403	69015	{
68404	69016	// variable u64 initialize goes out of scope
68405	69017	// emitted destructur for type u64

		@@ -68410,10 +69022,10 @@
68410	69022	// variable u64 idx_______ goes out of scope
68411	69023	// emitted destructur for type u64
68412	69024	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
68413		- state.addr = 18446744073709547565LLU; // 99999999_r'''''''''''''''
	69025	+ state.addr = 18446744073709547525LLU; // 99999999_E'''''''''''''''
68414	69026	break;
68415	69027	}
68416		- case 18446744073709547565LLU: // 99999999_r'''''''''''''''
	69028	+ case 18446744073709547525LLU: // 99999999_E'''''''''''''''
68417	69029	{
68418	69030	// ACCUMULATE ARGUMENTS - BEGIN
68419	69031	{

		@@ -68425,7 +69037,7 @@
68425	69037	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68426	69038	}
68427	69039	// ACCUMULATE ARGUMENTS - END
68428		- uint64_t return_to = 18446744073709547557LLU;
	69040	+ uint64_t return_to = 18446744073709547517LLU;
68429	69041	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
68430	69042	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68431	69043	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68434,17 +69046,17 @@
68434	69046	state.addr = 517555565476695680LLU; // assertu64_
68435	69047	break;
68436	69048	}
68437		- case 18446744073709547557LLU: // 99999999_j'''''''''''''''
	69049	+ case 18446744073709547517LLU: // 9999999897'''''''''''''''
68438	69050	{
68439		- state.addr = 18446744073709547558LLU; // 99999999_k'''''''''''''''
	69051	+ state.addr = 18446744073709547518LLU; // 9999999898'''''''''''''''
68440	69052	break;
68441	69053	}
68442		- case 18446744073709547558LLU: // 99999999_k'''''''''''''''
	69054	+ case 18446744073709547518LLU: // 9999999898'''''''''''''''
68443	69055	{
68444		- state.addr = 18446744073709547566LLU; // 99999999_s'''''''''''''''
	69056	+ state.addr = 18446744073709547526LLU; // 99999999_F'''''''''''''''
68445	69057	break;
68446	69058	}
68447		- case 18446744073709547566LLU: // 99999999_s'''''''''''''''
	69059	+ case 18446744073709547526LLU: // 99999999_F'''''''''''''''
68448	69060	{
68449	69061	// ACCUMULATE ARGUMENTS - BEGIN
68450	69062	{

		@@ -68452,7 +69064,7 @@
68452	69064	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68453	69065	}
68454	69066	// ACCUMULATE ARGUMENTS - END
68455		- uint64_t return_to = 18446744073709547555LLU;
	69067	+ uint64_t return_to = 18446744073709547515LLU;
68456	69068	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68457	69069	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68458	69070	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68461,12 +69073,12 @@
68461	69073	state.addr = 839519719621918720LLU; // skipws____
68462	69074	break;
68463	69075	}
68464		- case 18446744073709547555LLU: // 99999999_h'''''''''''''''
	69076	+ case 18446744073709547515LLU: // 9999999895'''''''''''''''
68465	69077	{
68466		- state.addr = 18446744073709547556LLU; // 99999999_i'''''''''''''''
	69078	+ state.addr = 18446744073709547516LLU; // 9999999896'''''''''''''''
68467	69079	break;
68468	69080	}
68469		- case 18446744073709547556LLU: // 99999999_i'''''''''''''''
	69081	+ case 18446744073709547516LLU: // 9999999896'''''''''''''''
68470	69082	{
68471	69083	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
68472	69084	if(')' != (char)getchar())

		@@ -68483,7 +69095,7 @@
68483	69095	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68484	69096	}
68485	69097	// ACCUMULATE ARGUMENTS - END
68486		- uint64_t return_to = 18446744073709547554LLU;
	69098	+ uint64_t return_to = 18446744073709547514LLU;
68487	69099	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68488	69100	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68489	69101	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68492,7 +69104,7 @@
68492	69104	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
68493	69105	break;
68494	69106	}
68495		- case 18446744073709547554LLU: // 99999999_g'''''''''''''''
	69107	+ case 18446744073709547514LLU: // 9999999894'''''''''''''''
68496	69108	{
68497	69109	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 19
68498	69110	// variable u64 mutable___ goes out of scope

		@@ -68506,18 +69118,18 @@
68506	69118	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
68507	69119	heap.availilable_size_for_dynamic_objects += 0LLU;
68508	69120	heap.availilable_size_for_dynamic_objects += 0LLU;
68509		- state.addr = 18446744073709547553LLU; // 99999999_f'''''''''''''''
	69121	+ state.addr = 18446744073709547513LLU; // 9999999893'''''''''''''''
68510	69122	break;
68511	69123	}
68512		- case 18446744073709547590LLU: // 99999999AF'''''''''''''''
	69124	+ case 18446744073709547550LLU: // 99999999_c'''''''''''''''
68513	69125	{
68514	69126	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 782701543416397824LLU;
68515	69127
68516	69128	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
68517		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547552LLU : 18446744073709547551LLU;
	69129	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547512LLU : 18446744073709547511LLU;
68518	69130	break;
68519	69131	}
68520		- case 18446744073709547552LLU: // 99999999_e'''''''''''''''
	69132	+ case 18446744073709547512LLU: // 9999999892'''''''''''''''
68521	69133	{
68522	69134	{
68523	69135	uint64_t arg = 0LLU;

		@@ -68541,7 +69153,7 @@
68541	69153	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68542	69154	}
68543	69155	// ACCUMULATE ARGUMENTS - END
68544		- uint64_t return_to = 18446744073709547549LLU;
	69156	+ uint64_t return_to = 18446744073709547509LLU;
68545	69157	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68546	69158	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68547	69159	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68550,12 +69162,12 @@
68550	69162	state.addr = 861504796319285248LLU; // typeu64___
68551	69163	break;
68552	69164	}
68553		- case 18446744073709547549LLU: // 99999999_b'''''''''''''''
	69165	+ case 18446744073709547509LLU: // 999999989z'''''''''''''''
68554	69166	{
68555		- state.addr = 18446744073709547550LLU; // 99999999_c'''''''''''''''
	69167	+ state.addr = 18446744073709547510LLU; // 9999999890'''''''''''''''
68556	69168	break;
68557	69169	}
68558		- case 18446744073709547550LLU: // 99999999_c'''''''''''''''
	69170	+ case 18446744073709547510LLU: // 9999999890'''''''''''''''
68559	69171	{
68560	69172	// ACCUMULATE ARGUMENTS - BEGIN
68561	69173	{

		@@ -68563,7 +69175,7 @@
68563	69175	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68564	69176	}
68565	69177	// ACCUMULATE ARGUMENTS - END
68566		- uint64_t return_to = 18446744073709547547LLU;
	69178	+ uint64_t return_to = 18446744073709547507LLU;
68567	69179	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68568	69180	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68569	69181	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68572,12 +69184,12 @@
68572	69184	state.addr = 839519719621918720LLU; // skipws____
68573	69185	break;
68574	69186	}
68575		- case 18446744073709547547LLU: // 99999999_$'''''''''''''''
	69187	+ case 18446744073709547507LLU: // 999999989x'''''''''''''''
68576	69188	{
68577		- state.addr = 18446744073709547548LLU; // 99999999_a'''''''''''''''
	69189	+ state.addr = 18446744073709547508LLU; // 999999989y'''''''''''''''
68578	69190	break;
68579	69191	}
68580		- case 18446744073709547548LLU: // 99999999_a'''''''''''''''
	69192	+ case 18446744073709547508LLU: // 999999989y'''''''''''''''
68581	69193	{
68582	69194	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68583	69195	fprintf(stdout, "%s", "\n ");

		@@ -68587,7 +69199,7 @@
68587	69199	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68588	69200	}
68589	69201	// ACCUMULATE ARGUMENTS - END
68590		- uint64_t return_to = 18446744073709547543LLU;
	69202	+ uint64_t return_to = 18446744073709547503LLU;
68591	69203	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68592	69204	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68593	69205	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68596,12 +69208,12 @@
68596	69208	state.addr = 839519719621918720LLU; // skipws____
68597	69209	break;
68598	69210	}
68599		- case 18446744073709547543LLU: // 99999999_W'''''''''''''''
	69211	+ case 18446744073709547503LLU: // 999999989t'''''''''''''''
68600	69212	{
68601		- state.addr = 18446744073709547544LLU; // 99999999_X'''''''''''''''
	69213	+ state.addr = 18446744073709547504LLU; // 999999989u'''''''''''''''
68602	69214	break;
68603	69215	}
68604		- case 18446744073709547544LLU: // 99999999_X'''''''''''''''
	69216	+ case 18446744073709547504LLU: // 999999989u'''''''''''''''
68605	69217	{
68606	69218	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68607	69219	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68622,7 +69234,7 @@
68622	69234	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68623	69235	}
68624	69236	// ACCUMULATE ARGUMENTS - END
68625		- uint64_t return_to = 18446744073709547541LLU;
	69237	+ uint64_t return_to = 18446744073709547501LLU;
68626	69238	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
68627	69239	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68628	69240	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68631,12 +69243,12 @@
68631	69243	state.addr = 517555565473470767LLU; // assertinit
68632	69244	break;
68633	69245	}
68634		- case 18446744073709547541LLU: // 99999999_U'''''''''''''''
	69246	+ case 18446744073709547501LLU: // 999999989r'''''''''''''''
68635	69247	{
68636		- state.addr = 18446744073709547542LLU; // 99999999_V'''''''''''''''
	69248	+ state.addr = 18446744073709547502LLU; // 999999989s'''''''''''''''
68637	69249	break;
68638	69250	}
68639		- case 18446744073709547542LLU: // 99999999_V'''''''''''''''
	69251	+ case 18446744073709547502LLU: // 999999989s'''''''''''''''
68640	69252	{
68641	69253	{
68642	69254	uint64_t arg = 0LLU;

		@@ -68712,7 +69324,7 @@
68712	69324	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68713	69325	}
68714	69326	// ACCUMULATE ARGUMENTS - END
68715		- uint64_t return_to = 18446744073709547539LLU;
	69327	+ uint64_t return_to = 18446744073709547499LLU;
68716	69328	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
68717	69329	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68718	69330	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68721,12 +69333,12 @@
68721	69333	state.addr = 787472342492567585LLU; // procvarref
68722	69334	break;
68723	69335	}
68724		- case 18446744073709547539LLU: // 99999999_S'''''''''''''''
	69336	+ case 18446744073709547499LLU: // 999999989p'''''''''''''''
68725	69337	{
68726		- state.addr = 18446744073709547540LLU; // 99999999_T'''''''''''''''
	69338	+ state.addr = 18446744073709547500LLU; // 999999989q'''''''''''''''
68727	69339	break;
68728	69340	}
68729		- case 18446744073709547540LLU: // 99999999_T'''''''''''''''
	69341	+ case 18446744073709547500LLU: // 999999989q'''''''''''''''
68730	69342	{
68731	69343	// variable u64 initialize goes out of scope
68732	69344	// emitted destructur for type u64

		@@ -68737,10 +69349,10 @@
68737	69349	// variable u64 idx_______ goes out of scope
68738	69350	// emitted destructur for type u64
68739	69351	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
68740		- state.addr = 18446744073709547545LLU; // 99999999_Y'''''''''''''''
	69352	+ state.addr = 18446744073709547505LLU; // 999999989v'''''''''''''''
68741	69353	break;
68742	69354	}
68743		- case 18446744073709547545LLU: // 99999999_Y'''''''''''''''
	69355	+ case 18446744073709547505LLU: // 999999989v'''''''''''''''
68744	69356	{
68745	69357	// ACCUMULATE ARGUMENTS - BEGIN
68746	69358	{

		@@ -68752,7 +69364,7 @@
68752	69364	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68753	69365	}
68754	69366	// ACCUMULATE ARGUMENTS - END
68755		- uint64_t return_to = 18446744073709547537LLU;
	69367	+ uint64_t return_to = 18446744073709547497LLU;
68756	69368	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
68757	69369	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68758	69370	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68761,12 +69373,12 @@
68761	69373	state.addr = 517555565476695680LLU; // assertu64_
68762	69374	break;
68763	69375	}
68764		- case 18446744073709547537LLU: // 99999999_Q'''''''''''''''
	69376	+ case 18446744073709547497LLU: // 999999989n'''''''''''''''
68765	69377	{
68766		- state.addr = 18446744073709547538LLU; // 99999999_R'''''''''''''''
	69378	+ state.addr = 18446744073709547498LLU; // 999999989o'''''''''''''''
68767	69379	break;
68768	69380	}
68769		- case 18446744073709547538LLU: // 99999999_R'''''''''''''''
	69381	+ case 18446744073709547498LLU: // 999999989o'''''''''''''''
68770	69382	{
68771	69383	{
68772	69384	uint64_t arg = 1LLU;

		@@ -68794,7 +69406,7 @@
68794	69406	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68795	69407	}
68796	69408	// ACCUMULATE ARGUMENTS - END
68797		- uint64_t return_to = 18446744073709547534LLU;
	69409	+ uint64_t return_to = 18446744073709547494LLU;
68798	69410	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
68799	69411	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68800	69412	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68803,25 +69415,25 @@
68803	69415	state.addr = 734295421765213120LLU; // mutassert_
68804	69416	break;
68805	69417	}
68806		- case 18446744073709547534LLU: // 99999999_N'''''''''''''''
	69418	+ case 18446744073709547494LLU: // 999999989k'''''''''''''''
68807	69419	{
68808		- state.addr = 18446744073709547535LLU; // 99999999_O'''''''''''''''
	69420	+ state.addr = 18446744073709547495LLU; // 999999989l'''''''''''''''
68809	69421	break;
68810	69422	}
68811		- case 18446744073709547535LLU: // 99999999_O'''''''''''''''
	69423	+ case 18446744073709547495LLU: // 999999989l'''''''''''''''
68812	69424	{
68813	69425	// variable u64 parnr_____ goes out of scope
68814	69426	// emitted destructur for type u64
68815	69427	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
68816		- state.addr = 18446744073709547536LLU; // 99999999_P'''''''''''''''
	69428	+ state.addr = 18446744073709547496LLU; // 999999989m'''''''''''''''
68817	69429	break;
68818	69430	}
68819		- case 18446744073709547536LLU: // 99999999_P'''''''''''''''
	69431	+ case 18446744073709547496LLU: // 999999989m'''''''''''''''
68820	69432	{
68821		- state.addr = 18446744073709547546LLU; // 99999999_Z'''''''''''''''
	69433	+ state.addr = 18446744073709547506LLU; // 999999989w'''''''''''''''
68822	69434	break;
68823	69435	}
68824		- case 18446744073709547546LLU: // 99999999_Z'''''''''''''''
	69436	+ case 18446744073709547506LLU: // 999999989w'''''''''''''''
68825	69437	{
68826	69438	// ACCUMULATE ARGUMENTS - BEGIN
68827	69439	{

		@@ -68829,7 +69441,7 @@
68829	69441	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68830	69442	}
68831	69443	// ACCUMULATE ARGUMENTS - END
68832		- uint64_t return_to = 18446744073709547532LLU;
	69444	+ uint64_t return_to = 18446744073709547492LLU;
68833	69445	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68834	69446	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68835	69447	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68838,12 +69450,12 @@
68838	69450	state.addr = 839519719621918720LLU; // skipws____
68839	69451	break;
68840	69452	}
68841		- case 18446744073709547532LLU: // 99999999_L'''''''''''''''
	69453	+ case 18446744073709547492LLU: // 999999989i'''''''''''''''
68842	69454	{
68843		- state.addr = 18446744073709547533LLU; // 99999999_M'''''''''''''''
	69455	+ state.addr = 18446744073709547493LLU; // 999999989j'''''''''''''''
68844	69456	break;
68845	69457	}
68846		- case 18446744073709547533LLU: // 99999999_M'''''''''''''''
	69458	+ case 18446744073709547493LLU: // 999999989j'''''''''''''''
68847	69459	{
68848	69460	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68849	69461	fprintf(stdout, "%s", " = parseid(&");

		@@ -68853,7 +69465,7 @@
68853	69465	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68854	69466	}
68855	69467	// ACCUMULATE ARGUMENTS - END
68856		- uint64_t return_to = 18446744073709547528LLU;
	69468	+ uint64_t return_to = 18446744073709547488LLU;
68857	69469	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
68858	69470	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68859	69471	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68862,12 +69474,12 @@
68862	69474	state.addr = 839519719621918720LLU; // skipws____
68863	69475	break;
68864	69476	}
68865		- case 18446744073709547528LLU: // 99999999_H'''''''''''''''
	69477	+ case 18446744073709547488LLU: // 999999989e'''''''''''''''
68866	69478	{
68867		- state.addr = 18446744073709547529LLU; // 99999999_I'''''''''''''''
	69479	+ state.addr = 18446744073709547489LLU; // 999999989f'''''''''''''''
68868	69480	break;
68869	69481	}
68870		- case 18446744073709547529LLU: // 99999999_I'''''''''''''''
	69482	+ case 18446744073709547489LLU: // 999999989f'''''''''''''''
68871	69483	{
68872	69484	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
68873	69485	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -68888,7 +69500,7 @@
68888	69500	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68889	69501	}
68890	69502	// ACCUMULATE ARGUMENTS - END
68891		- uint64_t return_to = 18446744073709547526LLU;
	69503	+ uint64_t return_to = 18446744073709547486LLU;
68892	69504	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
68893	69505	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68894	69506	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68897,12 +69509,12 @@
68897	69509	state.addr = 517555565473470767LLU; // assertinit
68898	69510	break;
68899	69511	}
68900		- case 18446744073709547526LLU: // 99999999_F'''''''''''''''
	69512	+ case 18446744073709547486LLU: // 999999989c'''''''''''''''
68901	69513	{
68902		- state.addr = 18446744073709547527LLU; // 99999999_G'''''''''''''''
	69514	+ state.addr = 18446744073709547487LLU; // 999999989d'''''''''''''''
68903	69515	break;
68904	69516	}
68905		- case 18446744073709547527LLU: // 99999999_G'''''''''''''''
	69517	+ case 18446744073709547487LLU: // 999999989d'''''''''''''''
68906	69518	{
68907	69519	{
68908	69520	uint64_t arg = 0LLU;

		@@ -68978,7 +69590,7 @@
68978	69590	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
68979	69591	}
68980	69592	// ACCUMULATE ARGUMENTS - END
68981		- uint64_t return_to = 18446744073709547524LLU;
	69593	+ uint64_t return_to = 18446744073709547484LLU;
68982	69594	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
68983	69595	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
68984	69596	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -68987,12 +69599,12 @@
68987	69599	state.addr = 787472342492567585LLU; // procvarref
68988	69600	break;
68989	69601	}
68990		- case 18446744073709547524LLU: // 99999999_D'''''''''''''''
	69602	+ case 18446744073709547484LLU: // 999999989a'''''''''''''''
68991	69603	{
68992		- state.addr = 18446744073709547525LLU; // 99999999_E'''''''''''''''
	69604	+ state.addr = 18446744073709547485LLU; // 999999989b'''''''''''''''
68993	69605	break;
68994	69606	}
68995		- case 18446744073709547525LLU: // 99999999_E'''''''''''''''
	69607	+ case 18446744073709547485LLU: // 999999989b'''''''''''''''
68996	69608	{
68997	69609	// variable u64 initialize goes out of scope
68998	69610	// emitted destructur for type u64

		@@ -69003,10 +69615,10 @@
69003	69615	// variable u64 idx_______ goes out of scope
69004	69616	// emitted destructur for type u64
69005	69617	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
69006		- state.addr = 18446744073709547530LLU; // 99999999_J'''''''''''''''
	69618	+ state.addr = 18446744073709547490LLU; // 999999989g'''''''''''''''
69007	69619	break;
69008	69620	}
69009		- case 18446744073709547530LLU: // 99999999_J'''''''''''''''
	69621	+ case 18446744073709547490LLU: // 999999989g'''''''''''''''
69010	69622	{
69011	69623	// ACCUMULATE ARGUMENTS - BEGIN
69012	69624	{

		@@ -69018,7 +69630,7 @@
69018	69630	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69019	69631	}
69020	69632	// ACCUMULATE ARGUMENTS - END
69021		- uint64_t return_to = 18446744073709547522LLU;
	69633	+ uint64_t return_to = 18446744073709547482LLU;
69022	69634	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
69023	69635	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69024	69636	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69027,17 +69639,17 @@
69027	69639	state.addr = 517555565476695680LLU; // assertu64_
69028	69640	break;
69029	69641	}
69030		- case 18446744073709547522LLU: // 99999999_B'''''''''''''''
	69642	+ case 18446744073709547482LLU: // 999999989Z'''''''''''''''
69031	69643	{
69032		- state.addr = 18446744073709547523LLU; // 99999999_C'''''''''''''''
	69644	+ state.addr = 18446744073709547483LLU; // 999999989$'''''''''''''''
69033	69645	break;
69034	69646	}
69035		- case 18446744073709547523LLU: // 99999999_C'''''''''''''''
	69647	+ case 18446744073709547483LLU: // 999999989$'''''''''''''''
69036	69648	{
69037		- state.addr = 18446744073709547531LLU; // 99999999_K'''''''''''''''
	69649	+ state.addr = 18446744073709547491LLU; // 999999989h'''''''''''''''
69038	69650	break;
69039	69651	}
69040		- case 18446744073709547531LLU: // 99999999_K'''''''''''''''
	69652	+ case 18446744073709547491LLU: // 999999989h'''''''''''''''
69041	69653	{
69042	69654	fprintf(stdout, "%s", ");");
69043	69655	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -69046,7 +69658,7 @@
69046	69658	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69047	69659	}
69048	69660	// ACCUMULATE ARGUMENTS - END
69049		- uint64_t return_to = 18446744073709547520LLU;
	69661	+ uint64_t return_to = 18446744073709547480LLU;
69050	69662	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69051	69663	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69052	69664	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69055,12 +69667,12 @@
69055	69667	state.addr = 839519719621918720LLU; // skipws____
69056	69668	break;
69057	69669	}
69058		- case 18446744073709547520LLU: // 99999999__'''''''''''''''
	69670	+ case 18446744073709547480LLU: // 999999989X'''''''''''''''
69059	69671	{
69060		- state.addr = 18446744073709547521LLU; // 99999999_A'''''''''''''''
	69672	+ state.addr = 18446744073709547481LLU; // 999999989Y'''''''''''''''
69061	69673	break;
69062	69674	}
69063		- case 18446744073709547521LLU: // 99999999_A'''''''''''''''
	69675	+ case 18446744073709547481LLU: // 999999989Y'''''''''''''''
69064	69676	{
69065	69677	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
69066	69678	if(')' != (char)getchar())

		@@ -69078,7 +69690,7 @@
69078	69690	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69079	69691	}
69080	69692	// ACCUMULATE ARGUMENTS - END
69081		- uint64_t return_to = 18446744073709547518LLU;
	69693	+ uint64_t return_to = 18446744073709547478LLU;
69082	69694	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
69083	69695	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69084	69696	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69087,12 +69699,12 @@
69087	69699	state.addr = 517555565476695680LLU; // assertu64_
69088	69700	break;
69089	69701	}
69090		- case 18446744073709547518LLU: // 9999999898'''''''''''''''
	69702	+ case 18446744073709547478LLU: // 999999989V'''''''''''''''
69091	69703	{
69092		- state.addr = 18446744073709547519LLU; // 9999999899'''''''''''''''
	69704	+ state.addr = 18446744073709547479LLU; // 999999989W'''''''''''''''
69093	69705	break;
69094	69706	}
69095		- case 18446744073709547519LLU: // 9999999899'''''''''''''''
	69707	+ case 18446744073709547479LLU: // 999999989W'''''''''''''''
69096	69708	{
69097	69709	{
69098	69710	uint64_t arg = 1LLU;

		@@ -69120,7 +69732,7 @@
69120	69732	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69121	69733	}
69122	69734	// ACCUMULATE ARGUMENTS - END
69123		- uint64_t return_to = 18446744073709547515LLU;
	69735	+ uint64_t return_to = 18446744073709547475LLU;
69124	69736	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
69125	69737	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69126	69738	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69129,20 +69741,20 @@
69129	69741	state.addr = 734295421765213120LLU; // mutassert_
69130	69742	break;
69131	69743	}
69132		- case 18446744073709547515LLU: // 9999999895'''''''''''''''
	69744	+ case 18446744073709547475LLU: // 999999989S'''''''''''''''
69133	69745	{
69134		- state.addr = 18446744073709547516LLU; // 9999999896'''''''''''''''
	69746	+ state.addr = 18446744073709547476LLU; // 999999989T'''''''''''''''
69135	69747	break;
69136	69748	}
69137		- case 18446744073709547516LLU: // 9999999896'''''''''''''''
	69749	+ case 18446744073709547476LLU: // 999999989T'''''''''''''''
69138	69750	{
69139	69751	// variable u64 parnr_____ goes out of scope
69140	69752	// emitted destructur for type u64
69141	69753	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
69142		- state.addr = 18446744073709547517LLU; // 9999999897'''''''''''''''
	69754	+ state.addr = 18446744073709547477LLU; // 999999989U'''''''''''''''
69143	69755	break;
69144	69756	}
69145		- case 18446744073709547517LLU: // 9999999897'''''''''''''''
	69757	+ case 18446744073709547477LLU: // 999999989U'''''''''''''''
69146	69758	{
69147	69759	// variable type______ type______ goes out of scope
69148	69760	// emitted destructur for type type______

		@@ -69152,7 +69764,7 @@
69152	69764	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69153	69765	}
69154	69766	// ACCUMULATE ARGUMENTS - END
69155		- uint64_t return_to = 18446744073709547514LLU;
	69767	+ uint64_t return_to = 18446744073709547474LLU;
69156	69768	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69157	69769	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69158	69770	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69161,7 +69773,7 @@
69161	69773	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
69162	69774	break;
69163	69775	}
69164		- case 18446744073709547514LLU: // 9999999894'''''''''''''''
	69776	+ case 18446744073709547474LLU: // 999999989R'''''''''''''''
69165	69777	{
69166	69778	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 19
69167	69779	// variable u64 mutable___ goes out of scope

		@@ -69175,18 +69787,18 @@
69175	69787	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
69176	69788	heap.availilable_size_for_dynamic_objects += 0LLU;
69177	69789	heap.availilable_size_for_dynamic_objects += 0LLU;
69178		- state.addr = 18446744073709547513LLU; // 9999999893'''''''''''''''
	69790	+ state.addr = 18446744073709547473LLU; // 999999989Q'''''''''''''''
69179	69791	break;
69180	69792	}
69181		- case 18446744073709547551LLU: // 99999999_d'''''''''''''''
	69793	+ case 18446744073709547511LLU: // 9999999891'''''''''''''''
69182	69794	{
69183	69795	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 782701543503953920LLU;
69184	69796
69185	69797	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
69186		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547512LLU : 18446744073709547511LLU;
	69798	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547472LLU : 18446744073709547471LLU;
69187	69799	break;
69188	69800	}
69189		- case 18446744073709547512LLU: // 9999999892'''''''''''''''
	69801	+ case 18446744073709547472LLU: // 999999989P'''''''''''''''
69190	69802	{
69191	69803	{
69192	69804	uint64_t arg = 0LLU;

		@@ -69210,7 +69822,7 @@
69210	69822	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69211	69823	}
69212	69824	// ACCUMULATE ARGUMENTS - END
69213		- uint64_t return_to = 18446744073709547509LLU;
	69825	+ uint64_t return_to = 18446744073709547469LLU;
69214	69826	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69215	69827	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69216	69828	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69219,12 +69831,12 @@
69219	69831	state.addr = 861504796319285248LLU; // typeu64___
69220	69832	break;
69221	69833	}
69222		- case 18446744073709547509LLU: // 999999989z'''''''''''''''
	69834	+ case 18446744073709547469LLU: // 999999989M'''''''''''''''
69223	69835	{
69224		- state.addr = 18446744073709547510LLU; // 9999999890'''''''''''''''
	69836	+ state.addr = 18446744073709547470LLU; // 999999989N'''''''''''''''
69225	69837	break;
69226	69838	}
69227		- case 18446744073709547510LLU: // 9999999890'''''''''''''''
	69839	+ case 18446744073709547470LLU: // 999999989N'''''''''''''''
69228	69840	{
69229	69841	// ACCUMULATE ARGUMENTS - BEGIN
69230	69842	{

		@@ -69232,7 +69844,7 @@
69232	69844	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69233	69845	}
69234	69846	// ACCUMULATE ARGUMENTS - END
69235		- uint64_t return_to = 18446744073709547507LLU;
	69847	+ uint64_t return_to = 18446744073709547467LLU;
69236	69848	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69237	69849	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69238	69850	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69241,12 +69853,12 @@
69241	69853	state.addr = 839519719621918720LLU; // skipws____
69242	69854	break;
69243	69855	}
69244		- case 18446744073709547507LLU: // 999999989x'''''''''''''''
	69856	+ case 18446744073709547467LLU: // 999999989K'''''''''''''''
69245	69857	{
69246		- state.addr = 18446744073709547508LLU; // 999999989y'''''''''''''''
	69858	+ state.addr = 18446744073709547468LLU; // 999999989L'''''''''''''''
69247	69859	break;
69248	69860	}
69249		- case 18446744073709547508LLU: // 999999989y'''''''''''''''
	69861	+ case 18446744073709547468LLU: // 999999989L'''''''''''''''
69250	69862	{
69251	69863	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
69252	69864	fprintf(stdout, "%s", "\n ");

		@@ -69256,7 +69868,7 @@
69256	69868	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69257	69869	}
69258	69870	// ACCUMULATE ARGUMENTS - END
69259		- uint64_t return_to = 18446744073709547503LLU;
	69871	+ uint64_t return_to = 18446744073709547463LLU;
69260	69872	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69261	69873	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69262	69874	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69265,12 +69877,12 @@
69265	69877	state.addr = 839519719621918720LLU; // skipws____
69266	69878	break;
69267	69879	}
69268		- case 18446744073709547503LLU: // 999999989t'''''''''''''''
	69880	+ case 18446744073709547463LLU: // 999999989G'''''''''''''''
69269	69881	{
69270		- state.addr = 18446744073709547504LLU; // 999999989u'''''''''''''''
	69882	+ state.addr = 18446744073709547464LLU; // 999999989H'''''''''''''''
69271	69883	break;
69272	69884	}
69273		- case 18446744073709547504LLU: // 999999989u'''''''''''''''
	69885	+ case 18446744073709547464LLU: // 999999989H'''''''''''''''
69274	69886	{
69275	69887	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
69276	69888	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -69291,7 +69903,7 @@
69291	69903	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69292	69904	}
69293	69905	// ACCUMULATE ARGUMENTS - END
69294		- uint64_t return_to = 18446744073709547501LLU;
	69906	+ uint64_t return_to = 18446744073709547461LLU;
69295	69907	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
69296	69908	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69297	69909	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69300,12 +69912,12 @@
69300	69912	state.addr = 517555565473470767LLU; // assertinit
69301	69913	break;
69302	69914	}
69303		- case 18446744073709547501LLU: // 999999989r'''''''''''''''
	69915	+ case 18446744073709547461LLU: // 999999989E'''''''''''''''
69304	69916	{
69305		- state.addr = 18446744073709547502LLU; // 999999989s'''''''''''''''
	69917	+ state.addr = 18446744073709547462LLU; // 999999989F'''''''''''''''
69306	69918	break;
69307	69919	}
69308		- case 18446744073709547502LLU: // 999999989s'''''''''''''''
	69920	+ case 18446744073709547462LLU: // 999999989F'''''''''''''''
69309	69921	{
69310	69922	{
69311	69923	uint64_t arg = 0LLU;

		@@ -69381,7 +69993,7 @@
69381	69993	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69382	69994	}
69383	69995	// ACCUMULATE ARGUMENTS - END
69384		- uint64_t return_to = 18446744073709547499LLU;
	69996	+ uint64_t return_to = 18446744073709547459LLU;
69385	69997	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
69386	69998	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69387	69999	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69390,12 +70002,12 @@
69390	70002	state.addr = 787472342492567585LLU; // procvarref
69391	70003	break;
69392	70004	}
69393		- case 18446744073709547499LLU: // 999999989p'''''''''''''''
	70005	+ case 18446744073709547459LLU: // 999999989C'''''''''''''''
69394	70006	{
69395		- state.addr = 18446744073709547500LLU; // 999999989q'''''''''''''''
	70007	+ state.addr = 18446744073709547460LLU; // 999999989D'''''''''''''''
69396	70008	break;
69397	70009	}
69398		- case 18446744073709547500LLU: // 999999989q'''''''''''''''
	70010	+ case 18446744073709547460LLU: // 999999989D'''''''''''''''
69399	70011	{
69400	70012	// variable u64 initialize goes out of scope
69401	70013	// emitted destructur for type u64

		@@ -69406,10 +70018,10 @@
69406	70018	// variable u64 idx_______ goes out of scope
69407	70019	// emitted destructur for type u64
69408	70020	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
69409		- state.addr = 18446744073709547505LLU; // 999999989v'''''''''''''''
	70021	+ state.addr = 18446744073709547465LLU; // 999999989I'''''''''''''''
69410	70022	break;
69411	70023	}
69412		- case 18446744073709547505LLU: // 999999989v'''''''''''''''
	70024	+ case 18446744073709547465LLU: // 999999989I'''''''''''''''
69413	70025	{
69414	70026	// ACCUMULATE ARGUMENTS - BEGIN
69415	70027	{

		@@ -69421,7 +70033,7 @@
69421	70033	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69422	70034	}
69423	70035	// ACCUMULATE ARGUMENTS - END
69424		- uint64_t return_to = 18446744073709547497LLU;
	70036	+ uint64_t return_to = 18446744073709547457LLU;
69425	70037	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
69426	70038	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69427	70039	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69430,12 +70042,12 @@
69430	70042	state.addr = 517555565476695680LLU; // assertu64_
69431	70043	break;
69432	70044	}
69433		- case 18446744073709547497LLU: // 999999989n'''''''''''''''
	70045	+ case 18446744073709547457LLU: // 999999989A'''''''''''''''
69434	70046	{
69435		- state.addr = 18446744073709547498LLU; // 999999989o'''''''''''''''
	70047	+ state.addr = 18446744073709547458LLU; // 999999989B'''''''''''''''
69436	70048	break;
69437	70049	}
69438		- case 18446744073709547498LLU: // 999999989o'''''''''''''''
	70050	+ case 18446744073709547458LLU: // 999999989B'''''''''''''''
69439	70051	{
69440	70052	{
69441	70053	uint64_t arg = 1LLU;

		@@ -69463,7 +70075,7 @@
69463	70075	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69464	70076	}
69465	70077	// ACCUMULATE ARGUMENTS - END
69466		- uint64_t return_to = 18446744073709547494LLU;
	70078	+ uint64_t return_to = 18446744073709547454LLU;
69467	70079	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
69468	70080	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69469	70081	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69472,25 +70084,25 @@
69472	70084	state.addr = 734295421765213120LLU; // mutassert_
69473	70085	break;
69474	70086	}
69475		- case 18446744073709547494LLU: // 999999989k'''''''''''''''
	70087	+ case 18446744073709547454LLU: // 9999999888'''''''''''''''
69476	70088	{
69477		- state.addr = 18446744073709547495LLU; // 999999989l'''''''''''''''
	70089	+ state.addr = 18446744073709547455LLU; // 9999999889'''''''''''''''
69478	70090	break;
69479	70091	}
69480		- case 18446744073709547495LLU: // 999999989l'''''''''''''''
	70092	+ case 18446744073709547455LLU: // 9999999889'''''''''''''''
69481	70093	{
69482	70094	// variable u64 parnr_____ goes out of scope
69483	70095	// emitted destructur for type u64
69484	70096	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
69485		- state.addr = 18446744073709547496LLU; // 999999989m'''''''''''''''
	70097	+ state.addr = 18446744073709547456LLU; // 999999989_'''''''''''''''
69486	70098	break;
69487	70099	}
69488		- case 18446744073709547496LLU: // 999999989m'''''''''''''''
	70100	+ case 18446744073709547456LLU: // 999999989_'''''''''''''''
69489	70101	{
69490		- state.addr = 18446744073709547506LLU; // 999999989w'''''''''''''''
	70102	+ state.addr = 18446744073709547466LLU; // 999999989J'''''''''''''''
69491	70103	break;
69492	70104	}
69493		- case 18446744073709547506LLU: // 999999989w'''''''''''''''
	70105	+ case 18446744073709547466LLU: // 999999989J'''''''''''''''
69494	70106	{
69495	70107	// ACCUMULATE ARGUMENTS - BEGIN
69496	70108	{

		@@ -69498,7 +70110,7 @@
69498	70110	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69499	70111	}
69500	70112	// ACCUMULATE ARGUMENTS - END
69501		- uint64_t return_to = 18446744073709547492LLU;
	70113	+ uint64_t return_to = 18446744073709547452LLU;
69502	70114	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69503	70115	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69504	70116	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69507,12 +70119,12 @@
69507	70119	state.addr = 839519719621918720LLU; // skipws____
69508	70120	break;
69509	70121	}
69510		- case 18446744073709547492LLU: // 999999989i'''''''''''''''
	70122	+ case 18446744073709547452LLU: // 9999999886'''''''''''''''
69511	70123	{
69512		- state.addr = 18446744073709547493LLU; // 999999989j'''''''''''''''
	70124	+ state.addr = 18446744073709547453LLU; // 9999999887'''''''''''''''
69513	70125	break;
69514	70126	}
69515		- case 18446744073709547493LLU: // 999999989j'''''''''''''''
	70127	+ case 18446744073709547453LLU: // 9999999887'''''''''''''''
69516	70128	{
69517	70129	matchid(",", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
69518	70130	fprintf(stdout, "%s", " = parsenr(&");

		@@ -69522,7 +70134,7 @@
69522	70134	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69523	70135	}
69524	70136	// ACCUMULATE ARGUMENTS - END
69525		- uint64_t return_to = 18446744073709547488LLU;
	70137	+ uint64_t return_to = 18446744073709547448LLU;
69526	70138	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69527	70139	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69528	70140	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69531,12 +70143,12 @@
69531	70143	state.addr = 839519719621918720LLU; // skipws____
69532	70144	break;
69533	70145	}
69534		- case 18446744073709547488LLU: // 999999989e'''''''''''''''
	70146	+ case 18446744073709547448LLU: // 9999999882'''''''''''''''
69535	70147	{
69536		- state.addr = 18446744073709547489LLU; // 999999989f'''''''''''''''
	70148	+ state.addr = 18446744073709547449LLU; // 9999999883'''''''''''''''
69537	70149	break;
69538	70150	}
69539		- case 18446744073709547489LLU: // 999999989f'''''''''''''''
	70151	+ case 18446744073709547449LLU: // 9999999883'''''''''''''''
69540	70152	{
69541	70153	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
69542	70154	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -69557,7 +70169,7 @@
69557	70169	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69558	70170	}
69559	70171	// ACCUMULATE ARGUMENTS - END
69560		- uint64_t return_to = 18446744073709547486LLU;
	70172	+ uint64_t return_to = 18446744073709547446LLU;
69561	70173	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
69562	70174	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69563	70175	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69566,12 +70178,12 @@
69566	70178	state.addr = 517555565473470767LLU; // assertinit
69567	70179	break;
69568	70180	}
69569		- case 18446744073709547486LLU: // 999999989c'''''''''''''''
	70181	+ case 18446744073709547446LLU: // 9999999880'''''''''''''''
69570	70182	{
69571		- state.addr = 18446744073709547487LLU; // 999999989d'''''''''''''''
	70183	+ state.addr = 18446744073709547447LLU; // 9999999881'''''''''''''''
69572	70184	break;
69573	70185	}
69574		- case 18446744073709547487LLU: // 999999989d'''''''''''''''
	70186	+ case 18446744073709547447LLU: // 9999999881'''''''''''''''
69575	70187	{
69576	70188	{
69577	70189	uint64_t arg = 0LLU;

		@@ -69647,7 +70259,7 @@
69647	70259	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69648	70260	}
69649	70261	// ACCUMULATE ARGUMENTS - END
69650		- uint64_t return_to = 18446744073709547484LLU;
	70262	+ uint64_t return_to = 18446744073709547444LLU;
69651	70263	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
69652	70264	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69653	70265	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69656,12 +70268,12 @@
69656	70268	state.addr = 787472342492567585LLU; // procvarref
69657	70269	break;
69658	70270	}
69659		- case 18446744073709547484LLU: // 999999989a'''''''''''''''
	70271	+ case 18446744073709547444LLU: // 999999988y'''''''''''''''
69660	70272	{
69661		- state.addr = 18446744073709547485LLU; // 999999989b'''''''''''''''
	70273	+ state.addr = 18446744073709547445LLU; // 999999988z'''''''''''''''
69662	70274	break;
69663	70275	}
69664		- case 18446744073709547485LLU: // 999999989b'''''''''''''''
	70276	+ case 18446744073709547445LLU: // 999999988z'''''''''''''''
69665	70277	{
69666	70278	// variable u64 initialize goes out of scope
69667	70279	// emitted destructur for type u64

		@@ -69672,10 +70284,10 @@
69672	70284	// variable u64 idx_______ goes out of scope
69673	70285	// emitted destructur for type u64
69674	70286	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
69675		- state.addr = 18446744073709547490LLU; // 999999989g'''''''''''''''
	70287	+ state.addr = 18446744073709547450LLU; // 9999999884'''''''''''''''
69676	70288	break;
69677	70289	}
69678		- case 18446744073709547490LLU: // 999999989g'''''''''''''''
	70290	+ case 18446744073709547450LLU: // 9999999884'''''''''''''''
69679	70291	{
69680	70292	// ACCUMULATE ARGUMENTS - BEGIN
69681	70293	{

		@@ -69687,7 +70299,7 @@
69687	70299	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69688	70300	}
69689	70301	// ACCUMULATE ARGUMENTS - END
69690		- uint64_t return_to = 18446744073709547482LLU;
	70302	+ uint64_t return_to = 18446744073709547442LLU;
69691	70303	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
69692	70304	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69693	70305	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69696,17 +70308,17 @@
69696	70308	state.addr = 517555565476695680LLU; // assertu64_
69697	70309	break;
69698	70310	}
69699		- case 18446744073709547482LLU: // 999999989Z'''''''''''''''
	70311	+ case 18446744073709547442LLU: // 999999988w'''''''''''''''
69700	70312	{
69701		- state.addr = 18446744073709547483LLU; // 999999989$'''''''''''''''
	70313	+ state.addr = 18446744073709547443LLU; // 999999988x'''''''''''''''
69702	70314	break;
69703	70315	}
69704		- case 18446744073709547483LLU: // 999999989$'''''''''''''''
	70316	+ case 18446744073709547443LLU: // 999999988x'''''''''''''''
69705	70317	{
69706		- state.addr = 18446744073709547491LLU; // 999999989h'''''''''''''''
	70318	+ state.addr = 18446744073709547451LLU; // 9999999885'''''''''''''''
69707	70319	break;
69708	70320	}
69709		- case 18446744073709547491LLU: // 999999989h'''''''''''''''
	70321	+ case 18446744073709547451LLU: // 9999999885'''''''''''''''
69710	70322	{
69711	70323	fprintf(stdout, "%s", ");");
69712	70324	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -69715,7 +70327,7 @@
69715	70327	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69716	70328	}
69717	70329	// ACCUMULATE ARGUMENTS - END
69718		- uint64_t return_to = 18446744073709547480LLU;
	70330	+ uint64_t return_to = 18446744073709547440LLU;
69719	70331	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69720	70332	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69721	70333	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69724,12 +70336,12 @@
69724	70336	state.addr = 839519719621918720LLU; // skipws____
69725	70337	break;
69726	70338	}
69727		- case 18446744073709547480LLU: // 999999989X'''''''''''''''
	70339	+ case 18446744073709547440LLU: // 999999988u'''''''''''''''
69728	70340	{
69729		- state.addr = 18446744073709547481LLU; // 999999989Y'''''''''''''''
	70341	+ state.addr = 18446744073709547441LLU; // 999999988v'''''''''''''''
69730	70342	break;
69731	70343	}
69732		- case 18446744073709547481LLU: // 999999989Y'''''''''''''''
	70344	+ case 18446744073709547441LLU: // 999999988v'''''''''''''''
69733	70345	{
69734	70346	ungetc((int)/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin);
69735	70347	if(')' != (char)getchar())

		@@ -69747,7 +70359,7 @@
69747	70359	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69748	70360	}
69749	70361	// ACCUMULATE ARGUMENTS - END
69750		- uint64_t return_to = 18446744073709547478LLU;
	70362	+ uint64_t return_to = 18446744073709547438LLU;
69751	70363	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
69752	70364	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69753	70365	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69756,12 +70368,12 @@
69756	70368	state.addr = 517555565476695680LLU; // assertu64_
69757	70369	break;
69758	70370	}
69759		- case 18446744073709547478LLU: // 999999989V'''''''''''''''
	70371	+ case 18446744073709547438LLU: // 999999988s'''''''''''''''
69760	70372	{
69761		- state.addr = 18446744073709547479LLU; // 999999989W'''''''''''''''
	70373	+ state.addr = 18446744073709547439LLU; // 999999988t'''''''''''''''
69762	70374	break;
69763	70375	}
69764		- case 18446744073709547479LLU: // 999999989W'''''''''''''''
	70376	+ case 18446744073709547439LLU: // 999999988t'''''''''''''''
69765	70377	{
69766	70378	{
69767	70379	uint64_t arg = 1LLU;

		@@ -69789,7 +70401,7 @@
69789	70401	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69790	70402	}
69791	70403	// ACCUMULATE ARGUMENTS - END
69792		- uint64_t return_to = 18446744073709547475LLU;
	70404	+ uint64_t return_to = 18446744073709547435LLU;
69793	70405	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0));
69794	70406	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69795	70407	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69798,20 +70410,20 @@
69798	70410	state.addr = 734295421765213120LLU; // mutassert_
69799	70411	break;
69800	70412	}
69801		- case 18446744073709547475LLU: // 999999989S'''''''''''''''
	70413	+ case 18446744073709547435LLU: // 999999988p'''''''''''''''
69802	70414	{
69803		- state.addr = 18446744073709547476LLU; // 999999989T'''''''''''''''
	70415	+ state.addr = 18446744073709547436LLU; // 999999988q'''''''''''''''
69804	70416	break;
69805	70417	}
69806		- case 18446744073709547476LLU: // 999999989T'''''''''''''''
	70418	+ case 18446744073709547436LLU: // 999999988q'''''''''''''''
69807	70419	{
69808	70420	// variable u64 parnr_____ goes out of scope
69809	70421	// emitted destructur for type u64
69810	70422	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference parnr_____ at 20
69811		- state.addr = 18446744073709547477LLU; // 999999989U'''''''''''''''
	70423	+ state.addr = 18446744073709547437LLU; // 999999988r'''''''''''''''
69812	70424	break;
69813	70425	}
69814		- case 18446744073709547477LLU: // 999999989U'''''''''''''''
	70426	+ case 18446744073709547437LLU: // 999999988r'''''''''''''''
69815	70427	{
69816	70428	// variable type______ type______ goes out of scope
69817	70429	// emitted destructur for type type______

		@@ -69821,7 +70433,7 @@
69821	70433	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69822	70434	}
69823	70435	// ACCUMULATE ARGUMENTS - END
69824		- uint64_t return_to = 18446744073709547474LLU;
	70436	+ uint64_t return_to = 18446744073709547434LLU;
69825	70437	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69826	70438	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69827	70439	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69830,7 +70442,7 @@
69830	70442	state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
69831	70443	break;
69832	70444	}
69833		- case 18446744073709547474LLU: // 999999989R'''''''''''''''
	70445	+ case 18446744073709547434LLU: // 999999988o'''''''''''''''
69834	70446	{
69835	70447	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 19
69836	70448	// variable u64 mutable___ goes out of scope

		@@ -69844,11 +70456,16 @@
69844	70456	(void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 16
69845	70457	heap.availilable_size_for_dynamic_objects += 0LLU;
69846	70458	heap.availilable_size_for_dynamic_objects += 0LLU;
69847		- state.addr = 18446744073709547473LLU; // 999999989Q'''''''''''''''
	70459	+ state.addr = 18446744073709547433LLU; // 999999988n'''''''''''''''
69848	70460	break;
69849	70461	}
69850		- case 18446744073709547511LLU: // 9999999891'''''''''''''''
	70462	+ case 18446744073709547471LLU: // 999999989O'''''''''''''''
69851	70463	{
	70464	+ state.addr = 18446744073709547433LLU; // 999999988n'''''''''''''''
	70465	+ break;
	70466	+ }
	70467	+ case 18446744073709547433LLU: // 999999988n'''''''''''''''
	70468	+ {
69852	70469	state.addr = 18446744073709547473LLU; // 999999989Q'''''''''''''''
69853	70470	break;
69854	70471	}

		@@ -69859,16 +70476,11 @@
69859	70476	}
69860	70477	case 18446744073709547513LLU: // 9999999893'''''''''''''''
69861	70478	{
69862		- state.addr = 18446744073709547553LLU; // 99999999_f'''''''''''''''
	70479	+ state.addr = 18446744073709547552LLU; // 99999999_e'''''''''''''''
69863	70480	break;
69864	70481	}
69865		- case 18446744073709547553LLU: // 99999999_f'''''''''''''''
	70482	+ case 18446744073709547552LLU: // 99999999_e'''''''''''''''
69866	70483	{
69867		- state.addr = 18446744073709547592LLU; // 99999999AH'''''''''''''''
69868		- break;
69869		- }
69870		- case 18446744073709547592LLU: // 99999999AH'''''''''''''''
69871		- {
69872	70484	// variable u64 sym_______ goes out of scope
69873	70485	// emitted destructur for type u64
69874	70486	(void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sym_______ at 15

		@@ -69917,10 +70529,10 @@
69917	70529	*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 532757394883346432LLU;
69918	70530
69919	70531	/builtin___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /callee_id_/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU));
69920		- state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547472LLU : 18446744073709547471LLU;
	70532	+ state.addr = access_heap(heap.data, LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709547432LLU : 18446744073709547431LLU;
69921	70533	break;
69922	70534	}
69923		- case 18446744073709547472LLU: // 999999989P'''''''''''''''
	70535	+ case 18446744073709547432LLU: // 999999988m'''''''''''''''
69924	70536	{
69925	70537	{
69926	70538	uint64_t arg = 0LLU;

		@@ -69944,7 +70556,7 @@
69944	70556	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69945	70557	}
69946	70558	// ACCUMULATE ARGUMENTS - END
69947		- uint64_t return_to = 18446744073709547469LLU;
	70559	+ uint64_t return_to = 18446744073709547429LLU;
69948	70560	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69949	70561	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69950	70562	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69953,12 +70565,12 @@
69953	70565	state.addr = 861504796319285248LLU; // typeu64___
69954	70566	break;
69955	70567	}
69956		- case 18446744073709547469LLU: // 999999989M'''''''''''''''
	70568	+ case 18446744073709547429LLU: // 999999988j'''''''''''''''
69957	70569	{
69958		- state.addr = 18446744073709547470LLU; // 999999989N'''''''''''''''
	70570	+ state.addr = 18446744073709547430LLU; // 999999988k'''''''''''''''
69959	70571	break;
69960	70572	}
69961		- case 18446744073709547470LLU: // 999999989N'''''''''''''''
	70573	+ case 18446744073709547430LLU: // 999999988k'''''''''''''''
69962	70574	{
69963	70575	// ACCUMULATE ARGUMENTS - BEGIN
69964	70576	{

		@@ -69966,7 +70578,7 @@
69966	70578	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69967	70579	}
69968	70580	// ACCUMULATE ARGUMENTS - END
69969		- uint64_t return_to = 18446744073709547467LLU;
	70581	+ uint64_t return_to = 18446744073709547427LLU;
69970	70582	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69971	70583	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69972	70584	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69975,12 +70587,12 @@
69975	70587	state.addr = 839519719621918720LLU; // skipws____
69976	70588	break;
69977	70589	}
69978		- case 18446744073709547467LLU: // 999999989K'''''''''''''''
	70590	+ case 18446744073709547427LLU: // 999999988h'''''''''''''''
69979	70591	{
69980		- state.addr = 18446744073709547468LLU; // 999999989L'''''''''''''''
	70592	+ state.addr = 18446744073709547428LLU; // 999999988i'''''''''''''''
69981	70593	break;
69982	70594	}
69983		- case 18446744073709547468LLU: // 999999989L'''''''''''''''
	70595	+ case 18446744073709547428LLU: // 999999988i'''''''''''''''
69984	70596	{
69985	70597	matchid("(", &/c_________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
69986	70598	fprintf(stdout, "%s", "\n ");

		@@ -69990,7 +70602,7 @@
69990	70602	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
69991	70603	}
69992	70604	// ACCUMULATE ARGUMENTS - END
69993		- uint64_t return_to = 18446744073709547463LLU;
	70605	+ uint64_t return_to = 18446744073709547423LLU;
69994	70606	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0));
69995	70607	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
69996	70608	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -69999,12 +70611,12 @@
69999	70611	state.addr = 839519719621918720LLU; // skipws____
70000	70612	break;
70001	70613	}
70002		- case 18446744073709547463LLU: // 999999989G'''''''''''''''
	70614	+ case 18446744073709547423LLU: // 999999988d'''''''''''''''
70003	70615	{
70004		- state.addr = 18446744073709547464LLU; // 999999989H'''''''''''''''
	70616	+ state.addr = 18446744073709547424LLU; // 999999988e'''''''''''''''
70005	70617	break;
70006	70618	}
70007		- case 18446744073709547464LLU: // 999999989H'''''''''''''''
	70619	+ case 18446744073709547424LLU: // 999999988e'''''''''''''''
70008	70620	{
70009	70621	/id________/LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/c_________/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)));
70010	70622	// ACCUMULATE ARGUMENTS - BEGIN

		@@ -70025,7 +70637,7 @@
70025	70637	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
70026	70638	}
70027	70639	// ACCUMULATE ARGUMENTS - END
70028		- uint64_t return_to = 18446744073709547461LLU;
	70640	+ uint64_t return_to = 18446744073709547421LLU;
70029	70641	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0));
70030	70642	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
70031	70643	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -70034,12 +70646,12 @@
70034	70646	state.addr = 517555565473470767LLU; // assertinit
70035	70647	break;
70036	70648	}
70037		- case 18446744073709547461LLU: // 999999989E'''''''''''''''
	70649	+ case 18446744073709547421LLU: // 999999988b'''''''''''''''
70038	70650	{
70039		- state.addr = 18446744073709547462LLU; // 999999989F'''''''''''''''
	70651	+ state.addr = 18446744073709547422LLU; // 999999988c'''''''''''''''
70040	70652	break;
70041	70653	}
70042		- case 18446744073709547462LLU: // 999999989F'''''''''''''''
	70654	+ case 18446744073709547422LLU: // 999999988c'''''''''''''''
70043	70655	{
70044	70656	{
70045	70657	uint64_t arg = 0LLU;

		@@ -70115,7 +70727,7 @@
70115	70727	LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
70116	70728	}
70117	70729	// ACCUMULATE ARGUMENTS - END
70118		- uint64_t return_to = 18446744073709547459LLU;
	70730	+ uint64_t return_to = 18446744073709547419LLU;
70119	70731	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0));
70120	70732	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
70121	70733	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

		@@ -70124,12 +70736,12 @@
70124	70736	state.addr = 787472342492567585LLU; // procvarref
70125	70737	break;
70126	70738	}
70127		- case 18446744073709547459LLU: // 999999989C'''''''''''''''
	70739	+ case 18446744073709547419LLU: // 999999988$'''''''''''''''
70128	70740	{
70129		- state.addr = 18446744073709547460LLU; // 999999989D'''''''''''''''
	70741	+ state.addr = 18446744073709547420LLU; // 999999988a'''''''''''''''
70130	70742	break;
70131	70743	}
70132		- case 18446744073709547460LLU: // 999999989D'''''''''''''''
	70744	+ case 18446744073709547420LLU: // 999999988a'''''''''''''''
70133	70745	{
70134	70746	// variable u64 initialize goes out of scope
70135	70747	// emitted destructur for type u64

		@@ -70140,10 +70752,10 @@
70140	70752	// variable u64 idx_______ goes out of scope
70141	70753	// emitted destructur for type u64
70142	70754	(void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference idx_______ at 20
70143		- state.addr = 18446744073709547465LLU; // 999999989I'''''''''''''''
	70755	+ state.addr = 18446744073709547425LLU; // 999999988f'''''''''''''''
70144	70756	break;
70145	70757	}
70146		- case 18446744073709547465LLU: // 999999989I'''''''''''''''
	70758	+ case 18446744073709547425LLU: // 999999988f'''''''''''''''
70147	70759	{
70148	70760	// ACCUMULATE ARGUMENTS - BEGIN
70149	70761	{

		@@ -70155,7 +70767,7 @@
70155	70767	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
70156	70768	}
70157	70769	// ACCUMULATE ARGUMENTS - END
70158		- uint64_t return_to = 18446744073709547457LLU;
	70770	+ uint64_t return_to = 18446744073709547417LLU;
70159	70771	const uint64_t restore = access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0));
70160	70772	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
70161	70773	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;

@@ -7016

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

Show on old repository browser