OSDN -- 开发和下载开源软件
简体中文翻译状态 translation status for zh
  • R/O
  • SSH
  • HTTPS

jpl: 提交


Commit MetaInfo

修订版1207 (tree)
时间2021-03-20 08:10:08
作者jakobthomsen

Log Message

retire version 5

更改概述

差异

--- tags/5_jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (nonexistent)
+++ tags/5_jpl_compiler_own_stack_and_heap(tree-closures-memory)-recursive/jpl_compiler.c (revision 1207)
@@ -0,0 +1,98667 @@
1+// generated c-code, do not edit!
2+#include <assert.h>
3+#include <ctype.h>
4+#include <stdbool.h>
5+#include <stdlib.h>
6+#include <stdint.h>
7+#include <stdio.h>
8+#include <string.h>
9+
10+uint64_t max(uint64_t x, uint64_t y)
11+{
12+ return x > y ? x : y;
13+}
14+
15+uint64_t min(uint64_t x, uint64_t y)
16+{
17+ return x < y ? x : y;
18+}
19+
20+void MATCHID(const char *id)
21+{
22+ uint64_t c = 0;
23+ while(*id)
24+ {
25+ c = getchar();
26+ if(*id != c)
27+ {
28+ fprintf(stderr, "failed to match %s at char %c\n", id, (char)c);
29+ exit(-1);
30+ }
31+ id++;
32+ }
33+}
34+
35+void matchid(const char *id, uint64_t *lookahead)
36+{
37+ while(*id)
38+ {
39+ if(*id != *lookahead)
40+ {
41+ fprintf(stderr, "failed to match %s at char %c\n", id, (char)*lookahead);
42+ exit(-1);
43+ }
44+ *lookahead = getchar();
45+ id++;
46+ }
47+}
48+
49+uint64_t PARSENR()
50+{
51+ uint64_t nr = 0;
52+ while(isdigit(ungetc(getchar(), stdin)))
53+ {
54+ nr = 10 * nr + ((uint64_t)getchar() - '0');
55+ }
56+ return nr;
57+}
58+
59+uint64_t parsenr(uint64_t *lookahead)
60+{
61+ ungetc((int)*lookahead, stdin);
62+ uint64_t nr = PARSENR();
63+ *lookahead = (uint64_t)getchar();
64+ return nr;
65+}
66+
67+uint64_t PARSEID()
68+{
69+
70+ uint64_t lookahead = 0;
71+ uint64_t id = 0;
72+ uint64_t n = 10;
73+ while(n > 0)
74+ {
75+ --n;
76+ lookahead = (uint32_t)ungetc(getchar(), stdin);
77+ if('_' == lookahead) id |= (lookahead - '_' + 0) << (n * 6);
78+ else if(isupper((uint32_t)lookahead)) id |= (lookahead - 'A' + 1) << (n * 6);
79+ else if('$' == lookahead) id |= (lookahead - '$' + 27) << (n * 6);
80+ else if(islower((uint32_t)lookahead)) id |= (lookahead - 'a' + 28) << (n * 6);
81+ else if(isdigit((uint32_t)lookahead)) id |= (lookahead - '0' + 54) << (n * 6);
82+ else
83+ {
84+ break;
85+ }
86+ (void)getchar();
87+ }
88+ return id;
89+}
90+
91+uint64_t parseid(uint64_t *lookahead)
92+{
93+
94+ ungetc((int)*lookahead, stdin);
95+ uint64_t id = PARSEID();
96+ *lookahead = (uint64_t)getchar();
97+ return id;
98+}
99+
100+void printid(FILE *const f, uint64_t id)
101+{
102+ uint64_t i = 10;
103+ while(i)
104+ {
105+ --i;
106+ uint64_t c = (id >> (i * 6llu)) & 63llu;
107+ if(c < 1) fprintf(f, "_");
108+ else if(c < 27) fprintf(f, "%c", (char)(c + 'A' - 1));
109+ else if(c < 28) fprintf(f, "$");
110+ else if(c < 54) fprintf(f, "%c", (char)(c + 'a' - 28));
111+ else /*if(c < 64)*/ fprintf(f, "%c", (char)(c + '0' - 54));
112+ }
113+ for(id = (id >> 60LLU) & 0xF; id > 0; id--)
114+ {
115+ fprintf(f, "'");
116+ }
117+}
118+
119+struct heap
120+{
121+ struct pair *data;
122+ uint64_t freelist;
123+ uint64_t availilable_size_for_dynamic_objects;
124+};
125+
126+struct state
127+{
128+ uint64_t addr;
129+};
130+
131+struct all
132+{
133+ struct heap heap;
134+ struct state state;
135+};
136+
137+
138+uint64_t compare(uint64_t left, uint64_t right)
139+{
140+ return left > right ? 1LLU : left < right ? ~0LLU : 0LLU;
141+}
142+
143+void swap(uint64_t *left, uint64_t *right)
144+{
145+ if(!left)
146+ {
147+ fprintf(stderr, "swap: left empty\n");
148+ exit(-1);
149+ }
150+ if(!right)
151+ {
152+ fprintf(stderr, "swap: right empty\n");
153+ exit(-1);
154+ }
155+ uint64_t tmp = *right;
156+ *right = *left;
157+ *left = tmp;
158+}
159+
160+uint64_t countsetbits(uint64_t value)
161+{
162+ uint64_t count;
163+ for (count = 0; value; count++)
164+ value &= value - 1LLU;
165+ return count;
166+}
167+
168+uint64_t highestsetbit(uint64_t value)
169+{
170+ uint64_t count = 0;
171+ while (value >>= 1LLU)
172+ {;
173+ count++;
174+ };
175+ return count;
176+}
177+
178+uint64_t encodeaddr(uint64_t root, uint64_t elem)
179+{
180+ return (root << 32) | (elem << 0);
181+}
182+
183+uint64_t decoderoot(uint64_t addr)
184+{
185+ return (addr >> 32);
186+}
187+
188+uint64_t decodeelem(uint64_t addr)
189+{
190+ return (addr & 0xFFFFFFFF);
191+}
192+
193+struct pair
194+{
195+ uint64_t elem0;
196+ uint64_t elem1;
197+};
198+
199+uint64_t *access_heap(struct pair *const heap, uint64_t addr)
200+{
201+ return (addr & 1) ? &heap[addr >> 1].elem1 : &heap[addr >> 1].elem0;
202+}
203+
204+uint64_t pair_move(struct heap *const heap, uint64_t *elem0, uint64_t *elem1)
205+{
206+ if(!heap)
207+ {
208+ fprintf(stderr, "pair_move: internal error - no heap!\n");
209+ exit(-1);
210+ }
211+ uint64_t new_addr = heap->freelist;
212+ if(!new_addr)
213+ {
214+ fprintf(stderr, "pair_move: out of heap\n");
215+ exit(-1);
216+ }
217+ heap->freelist = heap->data[new_addr].elem0;
218+ heap->data[new_addr].elem0 = *elem0;
219+ heap->data[new_addr].elem1 = *elem1;
220+ *elem0 = 0;
221+ *elem1 = 0;
222+ return new_addr;
223+}
224+
225+struct pair unpair(struct heap *const heap, uint64_t *pair)
226+{
227+ if(!heap)
228+ {
229+ fprintf(stderr, "unpair: internal error - no heap!\n");
230+ exit(-1);
231+ }
232+ if(!*pair)
233+ {
234+ fprintf(stderr, "unpair: null-reference!\n");
235+ exit(-1);
236+ }
237+ struct pair result = heap->data[*pair];
238+ heap->data[*pair].elem0 = heap->freelist;
239+ heap->data[*pair].elem1 = 0;
240+ heap->freelist = *pair;
241+ *pair = 0;
242+ return result;
243+}
244+
245+bool list_push_move(struct heap *const heap, uint64_t *const elem, uint64_t *const list, uint64_t weight)
246+{
247+ if(!heap)
248+ {
249+ fprintf(stderr, "list_push_move: internal error - no heap!\n");
250+ exit(-1);
251+ }
252+ if(weight > heap->availilable_size_for_dynamic_objects)
253+ {
254+ return false;
255+ }
256+ heap->availilable_size_for_dynamic_objects -= weight;
257+ *list = pair_move(heap, list, elem);
258+ return true;
259+}
260+
261+uint64_t list_pop_move(struct heap *const heap, uint64_t *const list, uint64_t weight)
262+{
263+ if(!heap)
264+ {
265+ fprintf(stderr, "list_pop_move: internal error - no heap!\n");
266+ exit(-1);
267+ }
268+ if(!*list)
269+ {
270+ fprintf(stderr, "list_pop_move: empty list!\n");
271+ exit(-1);
272+ }
273+ heap->availilable_size_for_dynamic_objects += weight;
274+ struct pair top = unpair(heap, list);
275+ *list = top.elem0;
276+ return top.elem1;
277+}
278+
279+void list_size(struct pair *const heapdata, uint64_t *const size, uint64_t list)
280+{
281+ if(!size)
282+ {
283+ fprintf(stderr, "list_size: no size\n");
284+ exit(-1);
285+ }
286+ for(*size = 0; list; ++*size)
287+ {
288+ list = heapdata[list].elem0;
289+ }
290+}
291+
292+void list_reverse(struct pair *const heapdata, uint64_t *root)
293+{
294+ uint64_t new_root = 0;
295+ while(*root)
296+ {
297+ uint64_t next = heapdata[*root].elem0;
298+ heapdata[*root].elem0 = new_root;
299+ new_root = *root;
300+ *root = next;
301+ }
302+ *root = new_root;
303+}
304+
305+void tree_push_move(struct heap *const heap, uint64_t size, uint64_t *const root, uint64_t *const elem)
306+{
307+ if(!heap)
308+ {
309+ fprintf(stderr, "tree_push_move: internal error - no heap!\n");
310+ exit(-1);
311+ }
312+ uint64_t spine = countsetbits(size++);
313+ if(!spine)
314+ {
315+ if(*root)
316+ {
317+ fprintf(stderr, "tree_push_move: destination uninitialized (at size = 0)!\n");
318+ exit(-1);
319+ }
320+ *root = *elem;
321+ *elem = 0;
322+ }
323+ else
324+ {
325+ uint64_t *ptr = root;
326+ while(spine > 1)
327+ {
328+ --spine;
329+ ptr = &heap->data[*ptr].elem1;
330+ }
331+ uint64_t new_addr = pair_move(heap, ptr, elem);
332+ *ptr = new_addr;
333+ }
334+}
335+
336+uint64_t tree_pop_move(struct heap *const heap, uint64_t size, uint64_t *const root)
337+{
338+ if(!heap)
339+ {
340+ fprintf(stderr, "tree_pop_move: internal error - no heap!\n");
341+ exit(-1);
342+ }
343+ uint64_t elem = 0;
344+ if(!size)
345+ {
346+ fprintf(stderr, "tree_pop_move: empty tree (size = 0)!\n");
347+ exit(-1);
348+ }
349+ uint64_t spine = countsetbits(--size);
350+ if(!*root && size > 0)
351+ {
352+ fprintf(stderr, "tree_pop_move: tree empty!\n");
353+ exit(-1);
354+ }
355+ if(!spine)
356+ {
357+ elem = *root;
358+ *root = 0;
359+ }
360+ else
361+ {
362+ uint64_t *ptr = root;
363+ while(spine > 1)
364+ {
365+ --spine;
366+ ptr = &heap->data[*ptr].elem1;
367+ }
368+ struct pair top = unpair(heap, ptr);
369+ elem = top.elem1;
370+ *ptr = top.elem0;
371+ }
372+ return elem;
373+}
374+
375+uint64_t *tree_elem_ref(struct pair *const heap, uint64_t size, uint64_t *const root, uint64_t index)
376+{
377+ uint64_t *node = root;
378+ if(index < size) // NOTE: this implies size > 0
379+ {
380+ uint64_t last = size - 1LLU;
381+ uint64_t height = highestsetbit(last) + 1LLU;
382+ while(height > 0)
383+ {
384+ height--;
385+ uint64_t mask = 1llu << height;
386+ if(last & mask)
387+ {
388+ if(index & mask)
389+ {
390+ node = &heap[*node].elem1;
391+ }
392+ else
393+ {
394+ node = &heap[*node].elem0;
395+ break;
396+ }
397+ }
398+
399+ }
400+ while(height > 0)
401+ {
402+ height--;
403+ uint64_t mask = 1LLU << height;
404+ if(index & mask)
405+ {
406+ node = &heap[*node].elem1;
407+ }
408+ else
409+ {
410+ node = &heap[*node].elem0;
411+ }
412+ }
413+ }
414+ else
415+ {
416+ fprintf(stderr, "tree_elem_access: index %llu out of range 0..%llu\n", (unsigned long long)index, (unsigned long long)size);
417+ exit(-1);
418+ }
419+ return node;
420+}
421+
422+uint64_t tree_elem_addr_internal(struct pair *const heap, uint64_t size, uint64_t const root, uint64_t index)
423+{
424+ bool flag = (root & 1);
425+ uint64_t addr = (root >> 1);
426+ if(index < size) // NOTE: this implies size > 0
427+ {
428+ uint64_t last = size - 1LLU;
429+ bool searchfulltree = true;
430+ uint64_t height = highestsetbit(last) + 1LLU;
431+ while(height > 0)
432+ {
433+ height--;
434+ uint64_t mask = 1llu << height;
435+ if(searchfulltree)
436+ {
437+ if(last & mask)
438+ {
439+ addr = flag ? heap[addr].elem1 : heap[addr].elem0;
440+ flag = index & mask;
441+ searchfulltree = flag;
442+ }
443+ }
444+ else
445+ {
446+ addr = flag ? heap[addr].elem1 : heap[addr].elem0;
447+ flag = index & mask;
448+ }
449+ }
450+ }
451+ else
452+ {
453+ fprintf(stderr, "tree_elem_access: index %llu out of range 0..%llu\n", (unsigned long long)index, (unsigned long long)size);
454+ exit(-1);
455+ }
456+ addr = ((addr << 1) | flag);
457+ return addr;
458+}
459+
460+uint64_t tree_elem_addr(struct pair *const heap, uint64_t size, uint64_t const root, uint64_t index)
461+{
462+ if(!root)
463+ {
464+ fprintf(stderr, "ERROR: null-addr in tree_elem_addr");
465+ exit(-1);
466+ }
467+ return tree_elem_addr_internal(heap, size, root, index);
468+}
469+
470+uint64_t tree_init(struct heap *const heap, uint64_t req_size)
471+{
472+ uint64_t root = 0;
473+ uint64_t elem = 0;
474+ for(uint64_t actual_size = 0; actual_size < req_size; actual_size++)
475+ {
476+ tree_push_move(heap, actual_size, &root, &elem);
477+ }
478+ return root;
479+}
480+
481+void tree_free(struct heap *const heap, uint64_t size, uint64_t *const root)
482+{
483+ for(; size > 0; size--)
484+ {
485+ (void)tree_pop_move(heap, size, root);
486+ }
487+ *root = 0;
488+}
489+
490+uint64_t move(uint64_t *const src)
491+{
492+ uint64_t dst = *src;
493+ *src = 0;
494+ return dst;
495+}
496+
497+uint64_t LOCAL_ACCESS_ADDR(struct pair *const heap, uint64_t size, uint64_t index)
498+{
499+ return tree_elem_addr(heap, /*skip baseinfo*/1llu + size, 1/*contains memroot*/, /*skip baseinfo*/1llu + index);
500+}
501+
502+uint64_t *LOCAL_ACCESS(struct pair *const heap, uint64_t size, uint64_t index)
503+{
504+ return access_heap(heap, LOCAL_ACCESS_ADDR(heap, size, index));
505+}
506+
507+void LOCAL_PUSH_MOVE(struct heap *const heap, uint64_t size, uint64_t *const root, uint64_t *const elem)
508+{
509+ tree_push_move(heap, /*skip baseinfo*/1llu + size, root, elem);
510+}
511+
512+uint64_t LOCAL_POP_MOVE(struct heap *const heap, uint64_t size, uint64_t *const root)
513+{
514+ return tree_pop_move(heap, /*skip baseinfo*/1llu + size, root);
515+}
516+
517+uint64_t countheap(struct heap *const heap)
518+{
519+ uint64_t node = heap->freelist;
520+ uint64_t heapcount = 0;
521+ for(heapcount = 0; node; node = heap->data[node].elem0)
522+ {
523+ heapcount++;
524+ }
525+ return heapcount;
526+}
527+
528+struct all init(struct pair *heapraw);
529+
530+int main(int argc, char **args)
531+{
532+ #define MEMSIZE (408LLU + 1)
533+ struct pair heapraw[33177LLU + 1];
534+ struct all all = init(heapraw);
535+ struct heap heap = all.heap;
536+ struct state state = all.state;
537+ while(state.addr)
538+ {
539+ switch(state.addr)
540+ {
541+ case 552446646280519680LLU: // copyu64___
542+ {
543+ {
544+ uint64_t arg = 0;
545+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
546+ }
547+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
548+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*value_____*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
549+ // variable u64 tmp_______ goes out of scope
550+ // emitted destructur for type u64
551+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 3
552+ // parameter u64 value_____ goes out of scope
553+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
554+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
555+ {
556+ uint64_t baseinfo = heap.data[0].elem1;
557+ struct pair pair = unpair(&heap, &baseinfo);
558+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
559+ state.addr = pair.elem1;
560+ }
561+ break;
562+ }
563+ case 819847183515949359LLU: // reportinit
564+ {
565+ fprintf(stderr, "%s", "in function ");
566+ printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
567+ fprintf(stderr, "%s", ": ");
568+ // parameter-reference u64 def_id____ goes out of scope
569+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 1
570+ {
571+ uint64_t baseinfo = heap.data[0].elem1;
572+ struct pair pair = unpair(&heap, &baseinfo);
573+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
574+ state.addr = pair.elem1;
575+ }
576+ break;
577+ }
578+ case 517555828430096990LLU: // assign_inc
579+ {
580+ ++/*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
581+ {
582+ uint64_t arg = 0;
583+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
584+ }
585+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
586+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
587+ // variable u64 result____ goes out of scope
588+ // emitted destructur for type u64
589+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
590+ // parameter-reference u64 value_____ goes out of scope
591+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
592+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
593+ {
594+ uint64_t baseinfo = heap.data[0].elem1;
595+ struct pair pair = unpair(&heap, &baseinfo);
596+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
597+ state.addr = pair.elem1;
598+ }
599+ break;
600+ }
601+ case 517555828430075934LLU: // assign_dec
602+ {
603+ --/*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
604+ {
605+ uint64_t arg = 0;
606+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
607+ }
608+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
609+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
610+ // variable u64 result____ goes out of scope
611+ // emitted destructur for type u64
612+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
613+ // parameter-reference u64 value_____ goes out of scope
614+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
615+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
616+ {
617+ uint64_t baseinfo = heap.data[0].elem1;
618+ struct pair pair = unpair(&heap, &baseinfo);
619+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
620+ state.addr = pair.elem1;
621+ }
622+ break;
623+ }
624+ case 787446708198178816LLU: // printnr___
625+ {
626+ fprintf(stdout, "%llu", (unsigned long long)/*nr________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
627+ fprintf(stdout, "%s", "LLU");
628+ // parameter-reference u64 nr________ goes out of scope
629+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 1
630+ {
631+ uint64_t baseinfo = heap.data[0].elem1;
632+ struct pair pair = unpair(&heap, &baseinfo);
633+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
634+ state.addr = pair.elem1;
635+ }
636+ break;
637+ }
638+ case 819847183517274112LLU: // reportnr__
639+ {
640+ fprintf(stderr, "%llu", (unsigned long long)/*nr________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
641+ // parameter-reference u64 nr________ goes out of scope
642+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 1
643+ {
644+ uint64_t baseinfo = heap.data[0].elem1;
645+ struct pair pair = unpair(&heap, &baseinfo);
646+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
647+ state.addr = pair.elem1;
648+ }
649+ break;
650+ }
651+ case 661609854409900032LLU: // iseof_____
652+ {
653+ {
654+ uint64_t arg = 0;
655+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
656+ }
657+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 255;
658+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) > /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
659+ // variable u64 result____ goes out of scope
660+ // emitted destructur for type u64
661+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
662+ // parameter-reference u64 lookahead_ goes out of scope
663+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
664+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
665+ {
666+ uint64_t baseinfo = heap.data[0].elem1;
667+ struct pair pair = unpair(&heap, &baseinfo);
668+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
669+ state.addr = pair.elem1;
670+ }
671+ break;
672+ }
673+ case 661649452408901632LLU: // isnoteof__
674+ {
675+ {
676+ uint64_t arg = 0;
677+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
678+ }
679+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 255;
680+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
681+ // variable u64 result____ goes out of scope
682+ // emitted destructur for type u64
683+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
684+ // parameter-reference u64 lookahead_ goes out of scope
685+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
686+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
687+ {
688+ uint64_t baseinfo = heap.data[0].elem1;
689+ struct pair pair = unpair(&heap, &baseinfo);
690+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
691+ state.addr = pair.elem1;
692+ }
693+ break;
694+ }
695+ case 661648768551262208LLU: // isnewline_
696+ {
697+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
698+ {
699+ state.addr = 18446744073709551614LLU; // 9999999998'''''''''''''''
700+ break;
701+ }
702+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
703+ // parameter-reference u64 __________ goes out of scope
704+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
705+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
706+ {
707+ uint64_t baseinfo = heap.data[0].elem1;
708+ struct pair pair = unpair(&heap, &baseinfo);
709+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
710+ state.addr = pair.elem1;
711+ }
712+ break;
713+ }
714+ case 18446744073709551614LLU: // 9999999998'''''''''''''''
715+ {
716+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
717+ // parameter-reference u64 __________ goes out of scope
718+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
719+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
720+ {
721+ uint64_t baseinfo = heap.data[0].elem1;
722+ struct pair pair = unpair(&heap, &baseinfo);
723+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
724+ state.addr = pair.elem1;
725+ }
726+ break;
727+ }
728+ case 661671490923528192LLU: // isspace___
729+ {
730+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 9)
731+ {
732+ state.addr = 18446744073709551612LLU; // 9999999996'''''''''''''''
733+ break;
734+ }
735+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
736+ // parameter-reference u64 __________ goes out of scope
737+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
738+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
739+ {
740+ uint64_t baseinfo = heap.data[0].elem1;
741+ struct pair pair = unpair(&heap, &baseinfo);
742+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
743+ state.addr = pair.elem1;
744+ }
745+ break;
746+ }
747+ case 18446744073709551612LLU: // 9999999996'''''''''''''''
748+ {
749+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
750+ {
751+ state.addr = 18446744073709551611LLU; // 9999999995'''''''''''''''
752+ break;
753+ }
754+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
755+ // parameter-reference u64 __________ goes out of scope
756+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
757+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
758+ {
759+ uint64_t baseinfo = heap.data[0].elem1;
760+ struct pair pair = unpair(&heap, &baseinfo);
761+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
762+ state.addr = pair.elem1;
763+ }
764+ break;
765+ }
766+ case 18446744073709551611LLU: // 9999999995'''''''''''''''
767+ {
768+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 11)
769+ {
770+ state.addr = 18446744073709551610LLU; // 9999999994'''''''''''''''
771+ break;
772+ }
773+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
774+ // parameter-reference u64 __________ goes out of scope
775+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
776+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
777+ {
778+ uint64_t baseinfo = heap.data[0].elem1;
779+ struct pair pair = unpair(&heap, &baseinfo);
780+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
781+ state.addr = pair.elem1;
782+ }
783+ break;
784+ }
785+ case 18446744073709551610LLU: // 9999999994'''''''''''''''
786+ {
787+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 12)
788+ {
789+ state.addr = 18446744073709551609LLU; // 9999999993'''''''''''''''
790+ break;
791+ }
792+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
793+ // parameter-reference u64 __________ goes out of scope
794+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
795+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
796+ {
797+ uint64_t baseinfo = heap.data[0].elem1;
798+ struct pair pair = unpair(&heap, &baseinfo);
799+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
800+ state.addr = pair.elem1;
801+ }
802+ break;
803+ }
804+ case 18446744073709551609LLU: // 9999999993'''''''''''''''
805+ {
806+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 13)
807+ {
808+ state.addr = 18446744073709551608LLU; // 9999999992'''''''''''''''
809+ break;
810+ }
811+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
812+ // parameter-reference u64 __________ goes out of scope
813+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
814+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
815+ {
816+ uint64_t baseinfo = heap.data[0].elem1;
817+ struct pair pair = unpair(&heap, &baseinfo);
818+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
819+ state.addr = pair.elem1;
820+ }
821+ break;
822+ }
823+ case 18446744073709551608LLU: // 9999999992'''''''''''''''
824+ {
825+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 32)
826+ {
827+ state.addr = 18446744073709551607LLU; // 9999999991'''''''''''''''
828+ break;
829+ }
830+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
831+ // parameter-reference u64 __________ goes out of scope
832+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
833+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
834+ {
835+ uint64_t baseinfo = heap.data[0].elem1;
836+ struct pair pair = unpair(&heap, &baseinfo);
837+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
838+ state.addr = pair.elem1;
839+ }
840+ break;
841+ }
842+ case 18446744073709551607LLU: // 9999999991'''''''''''''''
843+ {
844+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
845+ // parameter-reference u64 __________ goes out of scope
846+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
847+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
848+ {
849+ uint64_t baseinfo = heap.data[0].elem1;
850+ struct pair pair = unpair(&heap, &baseinfo);
851+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
852+ state.addr = pair.elem1;
853+ }
854+ break;
855+ }
856+ case 661680303159640064LLU: // isupper___
857+ {
858+ {
859+ uint64_t arg = 0;
860+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
861+ }
862+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 65;
863+ {
864+ uint64_t arg = 0;
865+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
866+ }
867+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
868+ {
869+ uint64_t arg = 0;
870+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
871+ }
872+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
873+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551605LLU : 18446744073709551604LLU;
874+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
875+ break;
876+ }
877+ case 18446744073709551605LLU: // 999999999z'''''''''''''''
878+ {
879+
880+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 90;
881+ {
882+ uint64_t arg = 0;
883+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
884+ }
885+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
886+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551603LLU : 18446744073709551602LLU;
887+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
888+ break;
889+ }
890+ case 18446744073709551603LLU: // 999999999x'''''''''''''''
891+ {
892+
893+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
894+ state.addr = 18446744073709551602LLU; // 999999999w'''''''''''''''
895+ break;
896+ }
897+ case 18446744073709551602LLU: // 999999999w'''''''''''''''
898+ {
899+ state.addr = 18446744073709551604LLU; // 999999999y'''''''''''''''
900+ break;
901+ }
902+ case 18446744073709551604LLU: // 999999999y'''''''''''''''
903+ {
904+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
905+ // variable u64 result____ goes out of scope
906+ // emitted destructur for type u64
907+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
908+ // variable u64 sym_______ goes out of scope
909+ // emitted destructur for type u64
910+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
911+ // parameter-reference u64 lookahead_ goes out of scope
912+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
913+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
914+ {
915+ uint64_t baseinfo = heap.data[0].elem1;
916+ struct pair pair = unpair(&heap, &baseinfo);
917+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
918+ state.addr = pair.elem1;
919+ }
920+ break;
921+ }
922+ case 661640659537756160LLU: // islower___
923+ {
924+ {
925+ uint64_t arg = 0;
926+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
927+ }
928+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 97;
929+ {
930+ uint64_t arg = 0;
931+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
932+ }
933+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
934+ {
935+ uint64_t arg = 0;
936+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
937+ }
938+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
939+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551601LLU : 18446744073709551600LLU;
940+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
941+ break;
942+ }
943+ case 18446744073709551601LLU: // 999999999v'''''''''''''''
944+ {
945+
946+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 122;
947+ {
948+ uint64_t arg = 0;
949+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
950+ }
951+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
952+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551599LLU : 18446744073709551598LLU;
953+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
954+ break;
955+ }
956+ case 18446744073709551599LLU: // 999999999t'''''''''''''''
957+ {
958+
959+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
960+ state.addr = 18446744073709551598LLU; // 999999999s'''''''''''''''
961+ break;
962+ }
963+ case 18446744073709551598LLU: // 999999999s'''''''''''''''
964+ {
965+ state.addr = 18446744073709551600LLU; // 999999999u'''''''''''''''
966+ break;
967+ }
968+ case 18446744073709551600LLU: // 999999999u'''''''''''''''
969+ {
970+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
971+ // variable u64 result____ goes out of scope
972+ // emitted destructur for type u64
973+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
974+ // variable u64 sym_______ goes out of scope
975+ // emitted destructur for type u64
976+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
977+ // parameter-reference u64 lookahead_ goes out of scope
978+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
979+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
980+ {
981+ uint64_t baseinfo = heap.data[0].elem1;
982+ struct pair pair = unpair(&heap, &baseinfo);
983+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
984+ state.addr = pair.elem1;
985+ }
986+ break;
987+ }
988+ case 661592067397386240LLU: // isalpha___
989+ {
990+ {
991+ uint64_t arg = 0;
992+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
993+ }
994+ // ACCUMULATE ARGUMENTS - BEGIN
995+ {
996+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
997+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
998+ }
999+ {
1000+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
1001+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1002+ }
1003+ // ACCUMULATE ARGUMENTS - END
1004+ uint64_t return_to = 18446744073709551594LLU;
1005+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1006+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1007+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1008+ heap.data[0].elem1 = heap.data[0].elem0;
1009+ heap.data[0].elem0 = restore;
1010+ state.addr = 661680303159640064LLU; // isupper___
1011+ break;
1012+ }
1013+ case 18446744073709551594LLU: // 999999999o'''''''''''''''
1014+ {
1015+ state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551597LLU : 18446744073709551596LLU;
1016+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
1017+ break;
1018+ }
1019+ case 18446744073709551597LLU: // 999999999r'''''''''''''''
1020+ {
1021+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
1022+ state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1023+ break;
1024+ }
1025+ case 18446744073709551596LLU: // 999999999q'''''''''''''''
1026+ {
1027+ // ACCUMULATE ARGUMENTS - BEGIN
1028+ {
1029+ uint64_t arg = *LOCAL_ACCESS(heap.data, 2LLU, 0LLU);
1030+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1031+ }
1032+ {
1033+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU);
1034+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1035+ }
1036+ // ACCUMULATE ARGUMENTS - END
1037+ uint64_t return_to = 18446744073709551593LLU;
1038+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1039+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1040+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1041+ heap.data[0].elem1 = heap.data[0].elem0;
1042+ heap.data[0].elem0 = restore;
1043+ state.addr = 661640659537756160LLU; // islower___
1044+ break;
1045+ }
1046+ case 18446744073709551593LLU: // 999999999n'''''''''''''''
1047+ {
1048+ state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1049+ break;
1050+ }
1051+ case 18446744073709551595LLU: // 999999999p'''''''''''''''
1052+ {
1053+ // parameter-reference u64 lookahead_ goes out of scope
1054+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1055+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1056+ {
1057+ uint64_t baseinfo = heap.data[0].elem1;
1058+ struct pair pair = unpair(&heap, &baseinfo);
1059+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1060+ state.addr = pair.elem1;
1061+ }
1062+ break;
1063+ }
1064+ case 661605045736570880LLU: // isdigit___
1065+ {
1066+ {
1067+ uint64_t arg = 0;
1068+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1069+ }
1070+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 48;
1071+ {
1072+ uint64_t arg = 0;
1073+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1074+ }
1075+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)) >= /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
1076+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551592LLU : 18446744073709551591LLU;
1077+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1078+ break;
1079+ }
1080+ case 18446744073709551592LLU: // 999999999m'''''''''''''''
1081+ {
1082+
1083+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 57;
1084+
1085+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1086+ state.addr = 18446744073709551591LLU; // 999999999l'''''''''''''''
1087+ break;
1088+ }
1089+ case 18446744073709551591LLU: // 999999999l'''''''''''''''
1090+ {
1091+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1092+ // variable u64 result____ goes out of scope
1093+ // emitted destructur for type u64
1094+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
1095+ // parameter-reference u64 lookahead_ goes out of scope
1096+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1097+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1098+ {
1099+ uint64_t baseinfo = heap.data[0].elem1;
1100+ struct pair pair = unpair(&heap, &baseinfo);
1101+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1102+ state.addr = pair.elem1;
1103+ }
1104+ break;
1105+ }
1106+ case 839519719621918720LLU: // skipws____
1107+ {
1108+ {
1109+ uint64_t arg = 0;
1110+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1111+ }
1112+ // ACCUMULATE ARGUMENTS - BEGIN
1113+ {
1114+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
1115+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1116+ }
1117+ {
1118+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 2LLU, 0LLU);
1119+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1120+ }
1121+ // ACCUMULATE ARGUMENTS - END
1122+ uint64_t return_to = 18446744073709551588LLU;
1123+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1124+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1125+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1126+ heap.data[0].elem1 = heap.data[0].elem0;
1127+ heap.data[0].elem0 = restore;
1128+ state.addr = 661671490923528192LLU; // isspace___
1129+ break;
1130+ }
1131+ case 18446744073709551588LLU: // 999999999i'''''''''''''''
1132+ {
1133+ state.addr = *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) ? 18446744073709551590LLU : 18446744073709551589LLU;
1134+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1135+ break;
1136+ }
1137+ case 18446744073709551590LLU: // 999999999k'''''''''''''''
1138+ {
1139+ {
1140+ uint64_t arg = 0;
1141+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1142+ }
1143+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 0;
1144+ state.addr = 18446744073709551587LLU; // 999999999h'''''''''''''''
1145+ break;
1146+ }
1147+ case 18446744073709551587LLU: // 999999999h'''''''''''''''
1148+ {
1149+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = (uint64_t)getchar();
1150+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU) || *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) > 255)
1151+ {
1152+ state.addr = 18446744073709551586LLU; // 999999999g'''''''''''''''
1153+ break;
1154+ }
1155+ {
1156+ uint64_t arg = 0;
1157+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1158+ }
1159+ // ACCUMULATE ARGUMENTS - BEGIN
1160+ {
1161+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
1162+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1163+ }
1164+ {
1165+ uint64_t arg = /*c_________*/LOCAL_ACCESS_ADDR(heap.data, 3LLU, 1LLU);
1166+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1167+ }
1168+ // ACCUMULATE ARGUMENTS - END
1169+ uint64_t return_to = 18446744073709551582LLU;
1170+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1171+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1172+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1173+ heap.data[0].elem1 = heap.data[0].elem0;
1174+ heap.data[0].elem0 = restore;
1175+ state.addr = 661671490923528192LLU; // isspace___
1176+ break;
1177+ }
1178+ case 18446744073709551582LLU: // 999999999c'''''''''''''''
1179+ {
1180+ state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551585LLU : 18446744073709551584LLU;
1181+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
1182+ break;
1183+ }
1184+ case 18446744073709551585LLU: // 999999999f'''''''''''''''
1185+ {
1186+ state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1187+ break;
1188+ }
1189+ case 18446744073709551584LLU: // 999999999e'''''''''''''''
1190+ {
1191+
1192+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = /*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU);
1193+ ungetc(0, stdin);
1194+ state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1195+ break;
1196+ }
1197+ case 18446744073709551583LLU: // 999999999d'''''''''''''''
1198+ {
1199+ state.addr = 18446744073709551587LLU; // 999999999h'''''''''''''''
1200+ break;
1201+ }
1202+ case 18446744073709551586LLU: // 999999999g'''''''''''''''
1203+ {
1204+ // variable u64 c_________ goes out of scope
1205+ // emitted destructur for type u64
1206+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2
1207+ state.addr = 18446744073709551589LLU; // 999999999j'''''''''''''''
1208+ break;
1209+ }
1210+ case 18446744073709551589LLU: // 999999999j'''''''''''''''
1211+ {
1212+ // parameter-reference u64 lookahead_ goes out of scope
1213+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 1
1214+ {
1215+ uint64_t baseinfo = heap.data[0].elem1;
1216+ struct pair pair = unpair(&heap, &baseinfo);
1217+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1218+ state.addr = pair.elem1;
1219+ }
1220+ break;
1221+ }
1222+ case 242277287585575139LLU: // MatchOptCh
1223+ {
1224+ {
1225+ uint64_t arg = 0;
1226+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1227+ }
1228+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*expected__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)) == /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
1229+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551581LLU : 18446744073709551580LLU;
1230+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1231+ break;
1232+ }
1233+ case 18446744073709551581LLU: // 999999999b'''''''''''''''
1234+ {
1235+
1236+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) = (uint64_t)getchar();
1237+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1LLU;
1238+ state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1239+ break;
1240+ }
1241+ case 18446744073709551580LLU: // 999999999a'''''''''''''''
1242+ {
1243+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0LLU;
1244+ state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1245+ break;
1246+ }
1247+ case 18446744073709551579LLU: // 999999999$'''''''''''''''
1248+ {
1249+ // parameter-reference u64 lookahead_ goes out of scope
1250+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 3
1251+ // parameter-reference u64 expected__ goes out of scope
1252+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference expected__ at 2
1253+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1254+ {
1255+ uint64_t baseinfo = heap.data[0].elem1;
1256+ struct pair pair = unpair(&heap, &baseinfo);
1257+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1258+ state.addr = pair.elem1;
1259+ }
1260+ break;
1261+ }
1262+ case 891913148528723755LLU: // verifyheap
1263+ {
1264+ fprintf(stdout, "%s", "\n uint64_t node = heap.freelist;");
1265+ fprintf(stdout, "%s", "\n for(uint64_t count = 0; count < ");
1266+ // ACCUMULATE ARGUMENTS - BEGIN
1267+ {
1268+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1269+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1270+ }
1271+ // ACCUMULATE ARGUMENTS - END
1272+ uint64_t return_to = 18446744073709551578LLU;
1273+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1274+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1275+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1276+ heap.data[0].elem1 = heap.data[0].elem0;
1277+ heap.data[0].elem0 = restore;
1278+ state.addr = 787446708198178816LLU; // printnr___
1279+ break;
1280+ }
1281+ case 18446744073709551578LLU: // 999999999Z'''''''''''''''
1282+ {
1283+ fprintf(stdout, "%s", "; count++)");
1284+ fprintf(stdout, "%s", "\n {");
1285+ fprintf(stdout, "%s", "\n if(0 == node)");
1286+ fprintf(stdout, "%s", "\n {");
1287+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1288+ // ACCUMULATE ARGUMENTS - BEGIN
1289+ {
1290+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1291+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1292+ }
1293+ // ACCUMULATE ARGUMENTS - END
1294+ uint64_t return_to = 18446744073709551577LLU;
1295+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1296+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1297+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1298+ heap.data[0].elem1 = heap.data[0].elem0;
1299+ heap.data[0].elem0 = restore;
1300+ state.addr = 787446708198178816LLU; // printnr___
1301+ break;
1302+ }
1303+ case 18446744073709551577LLU: // 999999999Y'''''''''''''''
1304+ {
1305+ fprintf(stdout, "%s", "; i > 0; i--)");
1306+ fprintf(stdout, "%s", "\n {");
1307+ fprintf(stdout, "%s", "\n fprintf(stderr, \"%llu: (%llu, %llu)\\n\", (unsigned long long)i, (unsigned long long)heap.data[i].elem0, (unsigned long long)heap.data[i].elem1);");
1308+ fprintf(stdout, "%s", "\n }");
1309+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST TRUNCATED (memory-leak?): zero-entry at length %llu\\n\", (unsigned long long)count);");
1310+ fprintf(stdout, "%s", "\n exit(-1);");
1311+ fprintf(stdout, "%s", "\n }");
1312+ fprintf(stdout, "%s", "\n node = heap.data[node].elem0;");
1313+ fprintf(stdout, "%s", "\n if(node > ");
1314+ // ACCUMULATE ARGUMENTS - BEGIN
1315+ {
1316+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1317+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1318+ }
1319+ // ACCUMULATE ARGUMENTS - END
1320+ uint64_t return_to = 18446744073709551576LLU;
1321+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1322+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1323+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1324+ heap.data[0].elem1 = heap.data[0].elem0;
1325+ heap.data[0].elem0 = restore;
1326+ state.addr = 787446708198178816LLU; // printnr___
1327+ break;
1328+ }
1329+ case 18446744073709551576LLU: // 999999999X'''''''''''''''
1330+ {
1331+ fprintf(stdout, "%s", ")");
1332+ fprintf(stdout, "%s", "\n {");
1333+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1334+ // ACCUMULATE ARGUMENTS - BEGIN
1335+ {
1336+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1337+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1338+ }
1339+ // ACCUMULATE ARGUMENTS - END
1340+ uint64_t return_to = 18446744073709551575LLU;
1341+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1342+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1343+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1344+ heap.data[0].elem1 = heap.data[0].elem0;
1345+ heap.data[0].elem0 = restore;
1346+ state.addr = 787446708198178816LLU; // printnr___
1347+ break;
1348+ }
1349+ case 18446744073709551575LLU: // 999999999W'''''''''''''''
1350+ {
1351+ fprintf(stdout, "%s", "; i > 0; i--)");
1352+ fprintf(stdout, "%s", "\n {");
1353+ fprintf(stdout, "%s", "\n fprintf(stderr, \"%llu: (%llu, %llu)\\n\", (unsigned long long)i, (unsigned long long)heap.data[i].elem0, (unsigned long long)heap.data[i].elem1);");
1354+ fprintf(stdout, "%s", "\n }");
1355+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CORRUPTED: entry %llu at length %llu exceeds bounds ");
1356+ fprintf(stdout, "%llu", (unsigned long long)/*heapsize__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1357+ fprintf(stdout, "%s", "\\n\", (unsigned long long)node, (unsigned long long)count);");
1358+ fprintf(stdout, "%s", "\n exit(-1);");
1359+ fprintf(stdout, "%s", "\n }");
1360+ fprintf(stdout, "%s", "\n }");
1361+ fprintf(stdout, "%s", "\n if(node)");
1362+ fprintf(stdout, "%s", "\n {");
1363+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1364+ // ACCUMULATE ARGUMENTS - BEGIN
1365+ {
1366+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1367+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1368+ }
1369+ // ACCUMULATE ARGUMENTS - END
1370+ uint64_t return_to = 18446744073709551574LLU;
1371+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1372+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1373+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1374+ heap.data[0].elem1 = heap.data[0].elem0;
1375+ heap.data[0].elem0 = restore;
1376+ state.addr = 787446708198178816LLU; // printnr___
1377+ break;
1378+ }
1379+ case 18446744073709551574LLU: // 999999999V'''''''''''''''
1380+ {
1381+ fprintf(stdout, "%s", "; i > 0; i--)");
1382+ fprintf(stdout, "%s", "\n {");
1383+ fprintf(stdout, "%s", "\n fprintf(stderr, \"%llu: (%llu, %llu)\\n\", (unsigned long long)i, (unsigned long long)heap.data[i].elem0, (unsigned long long)heap.data[i].elem1);");
1384+ fprintf(stdout, "%s", "\n }");
1385+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CIRCULAR\\n\");");
1386+ fprintf(stdout, "%s", "\n exit(-1);");
1387+ fprintf(stdout, "%s", "\n }");
1388+ fprintf(stdout, "%s", "\n");
1389+ // parameter-reference u64 heapsize__ goes out of scope
1390+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference heapsize__ at 1
1391+ {
1392+ uint64_t baseinfo = heap.data[0].elem1;
1393+ struct pair pair = unpair(&heap, &baseinfo);
1394+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1395+ state.addr = pair.elem1;
1396+ }
1397+ break;
1398+ }
1399+ case 18446744073709551572LLU: // 999999999T'''''''''''''''
1400+ {
1401+ // destructor for variant typelist__
1402+ {
1403+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1404+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1405+ }
1406+ // emitted destructur for type u64
1407+ // RELEASE temporary destructor-variable
1408+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1409+ // RELEASE destructor-argument
1410+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1411+ {
1412+ uint64_t baseinfo = heap.data[0].elem1;
1413+ struct pair pair = unpair(&heap, &baseinfo);
1414+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1415+ state.addr = pair.elem1;
1416+ }
1417+ break;
1418+ }
1419+ case 18446744073709551571LLU: // 999999999S'''''''''''''''
1420+ {
1421+ // destructor for variant typename__
1422+ {
1423+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1424+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1425+ }
1426+ // emitted destructur for type u64
1427+ // RELEASE temporary destructor-variable
1428+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1429+ // RELEASE destructor-argument
1430+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1431+ {
1432+ uint64_t baseinfo = heap.data[0].elem1;
1433+ struct pair pair = unpair(&heap, &baseinfo);
1434+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1435+ state.addr = pair.elem1;
1436+ }
1437+ break;
1438+ }
1439+ case 18446744073709551570LLU: // 999999999R'''''''''''''''
1440+ {
1441+ // destructor for variant typeu64___
1442+ // RELEASE destructor-argument
1443+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1444+ {
1445+ uint64_t baseinfo = heap.data[0].elem1;
1446+ struct pair pair = unpair(&heap, &baseinfo);
1447+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1448+ state.addr = pair.elem1;
1449+ }
1450+ break;
1451+ }
1452+ case 18446744073709551573LLU: // 999999999U'''''''''''''''
1453+ {
1454+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1455+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
1456+ state.addr = 18446744073709551570LLU + type_data.elem0;
1457+ break;
1458+ }
1459+ case 861504786250002432LLU: // typelist__
1460+ {
1461+ // union-constructor typelist__
1462+ {
1463+ uint64_t result_tuple = 0;
1464+ // copy references
1465+ {
1466+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1467+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1468+ }
1469+ // release parameters
1470+ {
1471+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1472+ }
1473+ {
1474+ uint64_t constridx = 2LLU;
1475+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1476+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1477+ }
1478+ }
1479+ {
1480+ uint64_t baseinfo = heap.data[0].elem1;
1481+ struct pair pair = unpair(&heap, &baseinfo);
1482+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1483+ state.addr = pair.elem1;
1484+ }
1485+ break;
1486+ }
1487+ case 861504788261634048LLU: // typename__
1488+ {
1489+ // union-constructor typename__
1490+ {
1491+ uint64_t result_tuple = 0;
1492+ // copy references
1493+ {
1494+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1495+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1496+ }
1497+ // release parameters
1498+ {
1499+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1500+ }
1501+ {
1502+ uint64_t constridx = 1LLU;
1503+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1504+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1505+ }
1506+ }
1507+ {
1508+ uint64_t baseinfo = heap.data[0].elem1;
1509+ struct pair pair = unpair(&heap, &baseinfo);
1510+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1511+ state.addr = pair.elem1;
1512+ }
1513+ break;
1514+ }
1515+ case 861504796319285248LLU: // typeu64___
1516+ {
1517+ // union-constructor typeu64___
1518+ {
1519+ uint64_t result_tuple = 0;
1520+ // copy references
1521+ // release parameters
1522+ {
1523+ uint64_t constridx = 0LLU;
1524+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1525+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1526+ }
1527+ }
1528+ {
1529+ uint64_t baseinfo = heap.data[0].elem1;
1530+ struct pair pair = unpair(&heap, &baseinfo);
1531+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1532+ state.addr = pair.elem1;
1533+ }
1534+ break;
1535+ }
1536+ case 589060043891015680LLU: // equtype___
1537+ {
1538+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1539+ {
1540+ state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
1541+ break;
1542+ }
1543+ {
1544+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1545+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1546+ }
1547+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1548+ {
1549+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1550+ state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
1551+ break;
1552+ }
1553+ {
1554+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1555+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1556+ }
1557+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
1558+ // parameter-reference type______ __________ goes out of scope
1559+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1560+ // parameter type______ __________ goes out of scope
1561+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1562+ // parameter-reference type______ __________ goes out of scope
1563+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1564+ // parameter type______ __________ goes out of scope
1565+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1566+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1567+ {
1568+ uint64_t baseinfo = heap.data[0].elem1;
1569+ struct pair pair = unpair(&heap, &baseinfo);
1570+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1571+ state.addr = pair.elem1;
1572+ }
1573+ break;
1574+ }
1575+ case 18446744073709551569LLU: // 999999999Q'''''''''''''''
1576+ {
1577+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1578+ {
1579+ state.addr = 18446744073709551568LLU; // 999999999P'''''''''''''''
1580+ break;
1581+ }
1582+ {
1583+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1584+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1585+ }
1586+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1587+ {
1588+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1589+ state.addr = 18446744073709551568LLU; // 999999999P'''''''''''''''
1590+ break;
1591+ }
1592+ {
1593+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1594+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1595+ }
1596+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1597+ // parameter-reference type______ __________ goes out of scope
1598+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1599+ // parameter type______ __________ goes out of scope
1600+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1601+ // parameter-reference type______ __________ goes out of scope
1602+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1603+ // parameter type______ __________ goes out of scope
1604+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1605+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1606+ {
1607+ uint64_t baseinfo = heap.data[0].elem1;
1608+ struct pair pair = unpair(&heap, &baseinfo);
1609+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1610+ state.addr = pair.elem1;
1611+ }
1612+ break;
1613+ }
1614+ case 18446744073709551568LLU: // 999999999P'''''''''''''''
1615+ {
1616+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1617+ {
1618+ state.addr = 18446744073709551567LLU; // 999999999O'''''''''''''''
1619+ break;
1620+ }
1621+ {
1622+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1623+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1624+ }
1625+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1626+ {
1627+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1628+ state.addr = 18446744073709551567LLU; // 999999999O'''''''''''''''
1629+ break;
1630+ }
1631+ {
1632+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1633+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1634+ }
1635+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1636+ // parameter-reference type______ __________ goes out of scope
1637+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1638+ // parameter type______ __________ goes out of scope
1639+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1640+ // parameter-reference type______ __________ goes out of scope
1641+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1642+ // parameter type______ __________ goes out of scope
1643+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1644+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1645+ {
1646+ uint64_t baseinfo = heap.data[0].elem1;
1647+ struct pair pair = unpair(&heap, &baseinfo);
1648+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1649+ state.addr = pair.elem1;
1650+ }
1651+ break;
1652+ }
1653+ case 18446744073709551567LLU: // 999999999O'''''''''''''''
1654+ {
1655+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1656+ {
1657+ state.addr = 18446744073709551566LLU; // 999999999N'''''''''''''''
1658+ break;
1659+ }
1660+ {
1661+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1662+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1663+ }
1664+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1665+ {
1666+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1667+ state.addr = 18446744073709551566LLU; // 999999999N'''''''''''''''
1668+ break;
1669+ }
1670+ {
1671+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1672+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1673+ }
1674+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1675+ // parameter-reference type______ __________ goes out of scope
1676+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1677+ // parameter type______ __________ goes out of scope
1678+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1679+ // parameter-reference type______ __________ goes out of scope
1680+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1681+ // parameter type______ __________ goes out of scope
1682+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1683+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1684+ {
1685+ uint64_t baseinfo = heap.data[0].elem1;
1686+ struct pair pair = unpair(&heap, &baseinfo);
1687+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1688+ state.addr = pair.elem1;
1689+ }
1690+ break;
1691+ }
1692+ case 18446744073709551566LLU: // 999999999N'''''''''''''''
1693+ {
1694+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1695+ {
1696+ state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1697+ break;
1698+ }
1699+ {
1700+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1701+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1702+ }
1703+ {
1704+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1705+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1706+ }
1707+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 1/*typename__*/)
1708+ {
1709+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1710+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1711+ state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1712+ break;
1713+ }
1714+ {
1715+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1716+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1717+ }
1718+ {
1719+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1720+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1721+ }
1722+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)) == /*y_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 6LLU));
1723+ // parameter-reference u64 y_________ goes out of scope
1724+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1725+ // parameter-reference type______ __________ goes out of scope
1726+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1727+ // parameter type______ __________ goes out of scope
1728+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1729+ // parameter-reference u64 x_________ goes out of scope
1730+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1731+ // parameter-reference type______ __________ goes out of scope
1732+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1733+ // parameter type______ __________ goes out of scope
1734+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1735+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1736+ {
1737+ uint64_t baseinfo = heap.data[0].elem1;
1738+ struct pair pair = unpair(&heap, &baseinfo);
1739+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1740+ state.addr = pair.elem1;
1741+ }
1742+ break;
1743+ }
1744+ case 18446744073709551565LLU: // 999999999M'''''''''''''''
1745+ {
1746+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1747+ {
1748+ state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1749+ break;
1750+ }
1751+ {
1752+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1753+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1754+ }
1755+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1756+ {
1757+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1758+ state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1759+ break;
1760+ }
1761+ {
1762+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1763+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1764+ }
1765+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1766+ // parameter-reference type______ __________ goes out of scope
1767+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1768+ // parameter type______ __________ goes out of scope
1769+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1770+ // parameter-reference type______ __________ goes out of scope
1771+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1772+ // parameter type______ __________ goes out of scope
1773+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1774+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1775+ {
1776+ uint64_t baseinfo = heap.data[0].elem1;
1777+ struct pair pair = unpair(&heap, &baseinfo);
1778+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1779+ state.addr = pair.elem1;
1780+ }
1781+ break;
1782+ }
1783+ case 18446744073709551564LLU: // 999999999L'''''''''''''''
1784+ {
1785+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1786+ {
1787+ state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1788+ break;
1789+ }
1790+ {
1791+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1792+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1793+ }
1794+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1795+ {
1796+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1797+ state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1798+ break;
1799+ }
1800+ {
1801+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1802+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1803+ }
1804+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1805+ // parameter-reference type______ __________ goes out of scope
1806+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1807+ // parameter type______ __________ goes out of scope
1808+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1809+ // parameter-reference type______ __________ goes out of scope
1810+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1811+ // parameter type______ __________ goes out of scope
1812+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1813+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1814+ {
1815+ uint64_t baseinfo = heap.data[0].elem1;
1816+ struct pair pair = unpair(&heap, &baseinfo);
1817+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1818+ state.addr = pair.elem1;
1819+ }
1820+ break;
1821+ }
1822+ case 18446744073709551563LLU: // 999999999K'''''''''''''''
1823+ {
1824+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1825+ {
1826+ state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1827+ break;
1828+ }
1829+ {
1830+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1831+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1832+ }
1833+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1834+ {
1835+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1836+ state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1837+ break;
1838+ }
1839+ {
1840+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1841+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1842+ }
1843+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1844+ // parameter-reference type______ __________ goes out of scope
1845+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1846+ // parameter type______ __________ goes out of scope
1847+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1848+ // parameter-reference type______ __________ goes out of scope
1849+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1850+ // parameter type______ __________ goes out of scope
1851+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1852+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1853+ {
1854+ uint64_t baseinfo = heap.data[0].elem1;
1855+ struct pair pair = unpair(&heap, &baseinfo);
1856+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1857+ state.addr = pair.elem1;
1858+ }
1859+ break;
1860+ }
1861+ case 18446744073709551562LLU: // 999999999J'''''''''''''''
1862+ {
1863+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1864+ {
1865+ state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1866+ break;
1867+ }
1868+ {
1869+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1870+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1871+ }
1872+ {
1873+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1874+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1875+ }
1876+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 2/*typelist__*/)
1877+ {
1878+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1879+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1880+ state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1881+ break;
1882+ }
1883+ {
1884+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1885+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1886+ }
1887+ {
1888+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1889+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1890+ }
1891+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)) == /*y_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 6LLU));
1892+ // parameter-reference u64 y_________ goes out of scope
1893+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1894+ // parameter-reference type______ __________ goes out of scope
1895+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1896+ // parameter type______ __________ goes out of scope
1897+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1898+ // parameter-reference u64 x_________ goes out of scope
1899+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1900+ // parameter-reference type______ __________ goes out of scope
1901+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1902+ // parameter type______ __________ goes out of scope
1903+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1904+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1905+ {
1906+ uint64_t baseinfo = heap.data[0].elem1;
1907+ struct pair pair = unpair(&heap, &baseinfo);
1908+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1909+ state.addr = pair.elem1;
1910+ }
1911+ break;
1912+ }
1913+ case 18446744073709551561LLU: // 999999999I'''''''''''''''
1914+ {
1915+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equtype___\n");
1916+ exit(-1);
1917+ break;
1918+ }
1919+ case 861504783110041600LLU: // typeinit__
1920+ {
1921+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 881834713755418624)
1922+ {
1923+ state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
1924+ break;
1925+ }
1926+ // ACCUMULATE ARGUMENTS - BEGIN
1927+ {
1928+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
1929+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1930+ }
1931+ // ACCUMULATE ARGUMENTS - END
1932+ uint64_t return_to = 18446744073709551559LLU;
1933+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1934+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1935+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1936+ heap.data[0].elem1 = heap.data[0].elem0;
1937+ heap.data[0].elem0 = restore;
1938+ state.addr = 861504796319285248LLU; // typeu64___
1939+ break;
1940+ }
1941+ case 18446744073709551559LLU: // 999999999G'''''''''''''''
1942+ {
1943+ // parameter-reference u64 subtype___ goes out of scope
1944+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
1945+ // parameter-reference u64 __________ goes out of scope
1946+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1947+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1948+ {
1949+ uint64_t baseinfo = heap.data[0].elem1;
1950+ struct pair pair = unpair(&heap, &baseinfo);
1951+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1952+ state.addr = pair.elem1;
1953+ }
1954+ break;
1955+ }
1956+ case 18446744073709551560LLU: // 999999999H'''''''''''''''
1957+ {
1958+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 712900180986298368)
1959+ {
1960+ state.addr = 18446744073709551558LLU; // 999999999F'''''''''''''''
1961+ break;
1962+ }
1963+ {
1964+ uint64_t arg = 0;
1965+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1966+ }
1967+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
1968+ // ACCUMULATE ARGUMENTS - BEGIN
1969+ {
1970+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
1971+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1972+ }
1973+ {
1974+ uint64_t arg = /*subtype___*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
1975+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1976+ }
1977+ // ACCUMULATE ARGUMENTS - END
1978+ uint64_t return_to = 18446744073709551557LLU;
1979+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1980+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1981+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1982+ heap.data[0].elem1 = heap.data[0].elem0;
1983+ heap.data[0].elem0 = restore;
1984+ state.addr = 861504786250002432LLU; // typelist__
1985+ break;
1986+ }
1987+ case 18446744073709551557LLU: // 999999999E'''''''''''''''
1988+ {
1989+ // variable u64 subtype___ goes out of scope
1990+ // (uninitialized -> no destructor-call)
1991+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 4
1992+ // parameter-reference u64 subtype___ goes out of scope
1993+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
1994+ // parameter-reference u64 __________ goes out of scope
1995+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1996+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1997+ {
1998+ uint64_t baseinfo = heap.data[0].elem1;
1999+ struct pair pair = unpair(&heap, &baseinfo);
2000+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2001+ state.addr = pair.elem1;
2002+ }
2003+ break;
2004+ }
2005+ case 18446744073709551558LLU: // 999999999F'''''''''''''''
2006+ {
2007+ {
2008+ uint64_t arg = 0;
2009+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2010+ }
2011+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2012+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551555LLU : 18446744073709551554LLU;
2013+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2014+ break;
2015+ }
2016+ case 18446744073709551555LLU: // 999999999C'''''''''''''''
2017+ {
2018+ fprintf(stderr, "%s", "typeinit: struct/union ");
2019+ printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)));
2020+ fprintf(stderr, "%s", " must not have subtype but found ");
2021+ printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2022+ state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
2023+ break;
2024+ }
2025+ case 18446744073709551554LLU: // 999999999B'''''''''''''''
2026+ {
2027+ {
2028+ uint64_t arg = 0;
2029+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2030+ }
2031+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
2032+ // ACCUMULATE ARGUMENTS - BEGIN
2033+ {
2034+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
2035+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2036+ }
2037+ {
2038+ uint64_t arg = /*maintype__*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2039+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2040+ }
2041+ // ACCUMULATE ARGUMENTS - END
2042+ uint64_t return_to = 18446744073709551553LLU;
2043+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2044+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2045+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2046+ heap.data[0].elem1 = heap.data[0].elem0;
2047+ heap.data[0].elem0 = restore;
2048+ state.addr = 861504788261634048LLU; // typename__
2049+ break;
2050+ }
2051+ case 18446744073709551553LLU: // 999999999A'''''''''''''''
2052+ {
2053+ // variable u64 maintype__ goes out of scope
2054+ // (uninitialized -> no destructor-call)
2055+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 4
2056+ // parameter-reference u64 subtype___ goes out of scope
2057+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2058+ // parameter-reference u64 maintype__ goes out of scope
2059+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 2
2060+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2061+ {
2062+ uint64_t baseinfo = heap.data[0].elem1;
2063+ struct pair pair = unpair(&heap, &baseinfo);
2064+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2065+ state.addr = pair.elem1;
2066+ }
2067+ break;
2068+ }
2069+ case 367395560426147840LLU: // TYPECOPY__
2070+ {
2071+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/)
2072+ {
2073+ state.addr = 18446744073709551552LLU; // 999999999_'''''''''''''''
2074+ break;
2075+ }
2076+ {
2077+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2078+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2079+ }
2080+ // ACCUMULATE ARGUMENTS - BEGIN
2081+ {
2082+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2083+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2084+ }
2085+ // ACCUMULATE ARGUMENTS - END
2086+ uint64_t return_to = 18446744073709551551LLU;
2087+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2088+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2089+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2090+ heap.data[0].elem1 = heap.data[0].elem0;
2091+ heap.data[0].elem0 = restore;
2092+ state.addr = 861504796319285248LLU; // typeu64___
2093+ break;
2094+ }
2095+ case 18446744073709551551LLU: // 9999999989'''''''''''''''
2096+ {
2097+ // parameter-reference type______ __________ goes out of scope
2098+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2099+ // parameter type______ __________ goes out of scope
2100+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2101+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2102+ {
2103+ uint64_t baseinfo = heap.data[0].elem1;
2104+ struct pair pair = unpair(&heap, &baseinfo);
2105+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2106+ state.addr = pair.elem1;
2107+ }
2108+ break;
2109+ }
2110+ case 18446744073709551552LLU: // 999999999_'''''''''''''''
2111+ {
2112+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/)
2113+ {
2114+ state.addr = 18446744073709551550LLU; // 9999999988'''''''''''''''
2115+ break;
2116+ }
2117+ {
2118+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2119+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2120+ }
2121+ {
2122+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2123+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2124+ }
2125+ {
2126+ uint64_t arg = 0;
2127+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2128+ }
2129+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2130+ // ACCUMULATE ARGUMENTS - BEGIN
2131+ {
2132+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2133+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2134+ }
2135+ {
2136+ uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2137+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2138+ }
2139+ // ACCUMULATE ARGUMENTS - END
2140+ uint64_t return_to = 18446744073709551549LLU;
2141+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2142+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2143+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2144+ heap.data[0].elem1 = heap.data[0].elem0;
2145+ heap.data[0].elem0 = restore;
2146+ state.addr = 861504788261634048LLU; // typename__
2147+ break;
2148+ }
2149+ case 18446744073709551549LLU: // 9999999987'''''''''''''''
2150+ {
2151+ // variable u64 tmp_______ goes out of scope
2152+ // (uninitialized -> no destructor-call)
2153+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2154+ // parameter-reference u64 name______ goes out of scope
2155+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2156+ // parameter-reference type______ __________ goes out of scope
2157+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2158+ // parameter type______ __________ goes out of scope
2159+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2160+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2161+ {
2162+ uint64_t baseinfo = heap.data[0].elem1;
2163+ struct pair pair = unpair(&heap, &baseinfo);
2164+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2165+ state.addr = pair.elem1;
2166+ }
2167+ break;
2168+ }
2169+ case 18446744073709551550LLU: // 9999999988'''''''''''''''
2170+ {
2171+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/)
2172+ {
2173+ state.addr = 18446744073709551548LLU; // 9999999986'''''''''''''''
2174+ break;
2175+ }
2176+ {
2177+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2178+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2179+ }
2180+ {
2181+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2182+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2183+ }
2184+ {
2185+ uint64_t arg = 0;
2186+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2187+ }
2188+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2189+ // ACCUMULATE ARGUMENTS - BEGIN
2190+ {
2191+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2192+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2193+ }
2194+ {
2195+ uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2196+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2197+ }
2198+ // ACCUMULATE ARGUMENTS - END
2199+ uint64_t return_to = 18446744073709551547LLU;
2200+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2201+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2202+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2203+ heap.data[0].elem1 = heap.data[0].elem0;
2204+ heap.data[0].elem0 = restore;
2205+ state.addr = 861504786250002432LLU; // typelist__
2206+ break;
2207+ }
2208+ case 18446744073709551547LLU: // 9999999985'''''''''''''''
2209+ {
2210+ // variable u64 tmp_______ goes out of scope
2211+ // (uninitialized -> no destructor-call)
2212+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2213+ // parameter-reference u64 name______ goes out of scope
2214+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2215+ // parameter-reference type______ __________ goes out of scope
2216+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2217+ // parameter type______ __________ goes out of scope
2218+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2219+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2220+ {
2221+ uint64_t baseinfo = heap.data[0].elem1;
2222+ struct pair pair = unpair(&heap, &baseinfo);
2223+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2224+ state.addr = pair.elem1;
2225+ }
2226+ break;
2227+ }
2228+ case 18446744073709551548LLU: // 9999999986'''''''''''''''
2229+ {
2230+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of TYPECOPY__\n");
2231+ exit(-1);
2232+ break;
2233+ }
2234+ case 819847183518878432LLU: // reporttype
2235+ {
2236+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2237+ {
2238+ state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
2239+ break;
2240+ }
2241+ {
2242+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2243+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2244+ }
2245+ fprintf(stderr, "%s", "u64");
2246+ // parameter-reference type______ __________ goes out of scope
2247+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2248+ // parameter type______ __________ goes out of scope
2249+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2250+ {
2251+ uint64_t baseinfo = heap.data[0].elem1;
2252+ struct pair pair = unpair(&heap, &baseinfo);
2253+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2254+ state.addr = pair.elem1;
2255+ }
2256+ break;
2257+ }
2258+ case 18446744073709551546LLU: // 9999999984'''''''''''''''
2259+ {
2260+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2261+ {
2262+ state.addr = 18446744073709551545LLU; // 9999999983'''''''''''''''
2263+ break;
2264+ }
2265+ {
2266+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2267+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2268+ }
2269+ {
2270+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2271+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2272+ }
2273+ printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2274+ // parameter-reference u64 maintype__ goes out of scope
2275+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2276+ // parameter-reference type______ __________ goes out of scope
2277+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2278+ // parameter type______ __________ goes out of scope
2279+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2280+ {
2281+ uint64_t baseinfo = heap.data[0].elem1;
2282+ struct pair pair = unpair(&heap, &baseinfo);
2283+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2284+ state.addr = pair.elem1;
2285+ }
2286+ break;
2287+ }
2288+ case 18446744073709551545LLU: // 9999999983'''''''''''''''
2289+ {
2290+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2291+ {
2292+ state.addr = 18446744073709551544LLU; // 9999999982'''''''''''''''
2293+ break;
2294+ }
2295+ {
2296+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2297+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2298+ }
2299+ {
2300+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2301+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2302+ }
2303+ {
2304+ uint64_t arg = 0;
2305+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2306+ }
2307+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2308+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551543LLU : 18446744073709551542LLU;
2309+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2310+ break;
2311+ }
2312+ case 18446744073709551543LLU: // 9999999981'''''''''''''''
2313+ {
2314+ fprintf(stderr, "%s", "list<");
2315+ printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2316+ fprintf(stderr, "%s", ">");
2317+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
2318+ break;
2319+ }
2320+ case 18446744073709551542LLU: // 9999999980'''''''''''''''
2321+ {
2322+ fprintf(stderr, "%s", "list<?>");
2323+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
2324+ break;
2325+ }
2326+ case 18446744073709551541LLU: // 999999998z'''''''''''''''
2327+ {
2328+ // parameter-reference u64 subtype___ goes out of scope
2329+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2330+ // parameter-reference type______ __________ goes out of scope
2331+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2332+ // parameter type______ __________ goes out of scope
2333+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2334+ {
2335+ uint64_t baseinfo = heap.data[0].elem1;
2336+ struct pair pair = unpair(&heap, &baseinfo);
2337+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2338+ state.addr = pair.elem1;
2339+ }
2340+ break;
2341+ }
2342+ case 18446744073709551544LLU: // 9999999982'''''''''''''''
2343+ {
2344+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttype\n");
2345+ exit(-1);
2346+ break;
2347+ }
2348+ case 787446708300855296LLU: // printtype_
2349+ {
2350+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2351+ {
2352+ state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
2353+ break;
2354+ }
2355+ {
2356+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2357+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2358+ }
2359+ fprintf(stdout, "%s", "u64");
2360+ // parameter-reference type______ __________ goes out of scope
2361+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2362+ // parameter type______ __________ goes out of scope
2363+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2364+ {
2365+ uint64_t baseinfo = heap.data[0].elem1;
2366+ struct pair pair = unpair(&heap, &baseinfo);
2367+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2368+ state.addr = pair.elem1;
2369+ }
2370+ break;
2371+ }
2372+ case 18446744073709551540LLU: // 999999998y'''''''''''''''
2373+ {
2374+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2375+ {
2376+ state.addr = 18446744073709551539LLU; // 999999998x'''''''''''''''
2377+ break;
2378+ }
2379+ {
2380+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2381+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2382+ }
2383+ {
2384+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2385+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2386+ }
2387+ printid(stdout, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2388+ // parameter-reference u64 maintype__ goes out of scope
2389+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2390+ // parameter-reference type______ __________ goes out of scope
2391+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2392+ // parameter type______ __________ goes out of scope
2393+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2394+ {
2395+ uint64_t baseinfo = heap.data[0].elem1;
2396+ struct pair pair = unpair(&heap, &baseinfo);
2397+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2398+ state.addr = pair.elem1;
2399+ }
2400+ break;
2401+ }
2402+ case 18446744073709551539LLU: // 999999998x'''''''''''''''
2403+ {
2404+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2405+ {
2406+ state.addr = 18446744073709551538LLU; // 999999998w'''''''''''''''
2407+ break;
2408+ }
2409+ {
2410+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2411+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2412+ }
2413+ {
2414+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2415+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2416+ }
2417+ {
2418+ uint64_t arg = 0;
2419+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2420+ }
2421+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2422+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551537LLU : 18446744073709551536LLU;
2423+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2424+ break;
2425+ }
2426+ case 18446744073709551537LLU: // 999999998v'''''''''''''''
2427+ {
2428+ fprintf(stdout, "%s", "list<");
2429+ printid(stdout, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2430+ fprintf(stdout, "%s", ">");
2431+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
2432+ break;
2433+ }
2434+ case 18446744073709551536LLU: // 999999998u'''''''''''''''
2435+ {
2436+ fprintf(stdout, "%s", "list<?>");
2437+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
2438+ break;
2439+ }
2440+ case 18446744073709551535LLU: // 999999998t'''''''''''''''
2441+ {
2442+ // parameter-reference u64 subtype___ goes out of scope
2443+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2444+ // parameter-reference type______ __________ goes out of scope
2445+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2446+ // parameter type______ __________ goes out of scope
2447+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2448+ {
2449+ uint64_t baseinfo = heap.data[0].elem1;
2450+ struct pair pair = unpair(&heap, &baseinfo);
2451+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2452+ state.addr = pair.elem1;
2453+ }
2454+ break;
2455+ }
2456+ case 18446744073709551538LLU: // 999999998w'''''''''''''''
2457+ {
2458+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of printtype_\n");
2459+ exit(-1);
2460+ break;
2461+ }
2462+ case 18446744073709551534LLU: // 999999998s'''''''''''''''
2463+ {
2464+ {
2465+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2466+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2467+ }
2468+ // emitted destructur for type u64
2469+ // RELEASE temporary destructor-variable
2470+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2471+ {
2472+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2473+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2474+ }
2475+ // emitted destructur for type u64
2476+ // RELEASE temporary destructor-variable
2477+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2478+ {
2479+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2480+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2481+ }
2482+ // emitted destructur for type type______
2483+ // ACCUMULATE ARGUMENTS - BEGIN
2484+ {
2485+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
2486+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2487+ }
2488+ // ACCUMULATE ARGUMENTS - END
2489+ uint64_t return_to = 18446744073709551533LLU;
2490+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2491+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2492+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2493+ heap.data[0].elem1 = heap.data[0].elem0;
2494+ heap.data[0].elem0 = restore;
2495+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
2496+ break;
2497+ }
2498+ case 18446744073709551533LLU: // 999999998r'''''''''''''''
2499+ {
2500+ // RELEASE temporary destructor-variable
2501+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2502+ // RELEASE destructor-argument
2503+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2504+ {
2505+ uint64_t baseinfo = heap.data[0].elem1;
2506+ struct pair pair = unpair(&heap, &baseinfo);
2507+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2508+ state.addr = pair.elem1;
2509+ }
2510+ break;
2511+ }
2512+ case 819859607768530944LLU: // resdest___
2513+ {
2514+ // struct-constructor resdest___
2515+ {
2516+ uint64_t result_tuple = 0;
2517+ // copy references
2518+ {
2519+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 0LLU + 1);
2520+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
2521+ }
2522+ {
2523+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 1LLU + 1);
2524+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
2525+ }
2526+ {
2527+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 2LLU + 1);
2528+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
2529+ }
2530+ // release parameters
2531+ {
2532+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2533+ }
2534+ {
2535+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2536+ }
2537+ {
2538+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2539+ }
2540+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
2541+ }
2542+ {
2543+ uint64_t baseinfo = heap.data[0].elem1;
2544+ struct pair pair = unpair(&heap, &baseinfo);
2545+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2546+ state.addr = pair.elem1;
2547+ }
2548+ break;
2549+ }
2550+ case 589059885019168768LLU: // equres____
2551+ {
2552+
2553+ // ACCUMULATE ARGUMENTS - BEGIN
2554+ {
2555+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2556+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2557+ }
2558+ {
2559+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
2560+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2561+ }
2562+ {
2563+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2564+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2565+ }
2566+ // ACCUMULATE ARGUMENTS - END
2567+ uint64_t return_to = 18446744073709551532LLU;
2568+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
2569+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2570+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2571+ heap.data[0].elem1 = heap.data[0].elem0;
2572+ heap.data[0].elem0 = restore;
2573+ state.addr = 589060043891015680LLU; // equtype___
2574+ break;
2575+ }
2576+ case 18446744073709551532LLU: // 999999998q'''''''''''''''
2577+ {
2578+ {
2579+ uint64_t arg = 0;
2580+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2581+ }
2582+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2583+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551531LLU : 18446744073709551530LLU;
2584+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2585+ break;
2586+ }
2587+ case 18446744073709551531LLU: // 999999998p'''''''''''''''
2588+ {
2589+
2590+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU));
2591+ {
2592+ uint64_t arg = 0;
2593+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2594+ }
2595+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2596+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551529LLU : 18446744073709551528LLU;
2597+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2598+ break;
2599+ }
2600+ case 18446744073709551529LLU: // 999999998n'''''''''''''''
2601+ {
2602+
2603+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU));
2604+ state.addr = 18446744073709551528LLU; // 999999998m'''''''''''''''
2605+ break;
2606+ }
2607+ case 18446744073709551528LLU: // 999999998m'''''''''''''''
2608+ {
2609+ state.addr = 18446744073709551530LLU; // 999999998o'''''''''''''''
2610+ break;
2611+ }
2612+ case 18446744073709551530LLU: // 999999998o'''''''''''''''
2613+ {
2614+ // parameter-reference resdest___ y_________ goes out of scope
2615+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
2616+ // parameter-reference resdest___ x_________ goes out of scope
2617+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
2618+ // parameter-reference u64 equal_____ goes out of scope
2619+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
2620+ {
2621+ uint64_t baseinfo = heap.data[0].elem1;
2622+ struct pair pair = unpair(&heap, &baseinfo);
2623+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2624+ state.addr = pair.elem1;
2625+ }
2626+ break;
2627+ }
2628+ case 333468934555566080LLU: // ResCopy___
2629+ {
2630+ {
2631+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2632+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2633+ }
2634+ {
2635+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
2636+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2637+ }
2638+ {
2639+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
2640+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2641+ }
2642+ // ACCUMULATE ARGUMENTS - BEGIN
2643+ {
2644+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2645+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2646+ }
2647+ {
2648+ uint64_t arg = heap.data[0].elem0;
2649+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2650+ }
2651+ {
2652+ uint64_t arg = 0;
2653+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2654+ }
2655+ // ACCUMULATE ARGUMENTS - BEGIN
2656+ {
2657+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2658+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2659+ }
2660+ {
2661+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
2662+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2663+ }
2664+ // ACCUMULATE ARGUMENTS - END
2665+ uint64_t return_to = 18446744073709551525LLU;
2666+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2667+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2668+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2669+ heap.data[0].elem1 = heap.data[0].elem0;
2670+ heap.data[0].elem0 = restore;
2671+ state.addr = 367395560426147840LLU; // TYPECOPY__
2672+ break;
2673+ }
2674+ case 18446744073709551525LLU: // 999999998j'''''''''''''''
2675+ {
2676+ {
2677+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2678+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2679+
2680+ {
2681+ uint64_t arg = exchange;
2682+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2683+ }
2684+ }
2685+ {
2686+ uint64_t arg = heap.data[0].elem0;
2687+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2688+ }
2689+ {
2690+ uint64_t arg = 0;
2691+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2692+ }
2693+ // ACCUMULATE ARGUMENTS - BEGIN
2694+ {
2695+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2696+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2697+ }
2698+ {
2699+ uint64_t arg = /*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
2700+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2701+ }
2702+ // ACCUMULATE ARGUMENTS - END
2703+ uint64_t return_to = 18446744073709551524LLU;
2704+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2705+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2706+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2707+ heap.data[0].elem1 = heap.data[0].elem0;
2708+ heap.data[0].elem0 = restore;
2709+ state.addr = 552446646280519680LLU; // copyu64___
2710+ break;
2711+ }
2712+ case 18446744073709551524LLU: // 999999998i'''''''''''''''
2713+ {
2714+ {
2715+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2716+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2717+
2718+ {
2719+ uint64_t arg = exchange;
2720+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2721+ }
2722+ }
2723+ {
2724+ uint64_t arg = heap.data[0].elem0;
2725+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2726+ }
2727+ {
2728+ uint64_t arg = 0;
2729+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2730+ }
2731+ // ACCUMULATE ARGUMENTS - BEGIN
2732+ {
2733+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2734+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2735+ }
2736+ {
2737+ uint64_t arg = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
2738+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2739+ }
2740+ // ACCUMULATE ARGUMENTS - END
2741+ uint64_t return_to = 18446744073709551523LLU;
2742+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2743+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2744+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2745+ heap.data[0].elem1 = heap.data[0].elem0;
2746+ heap.data[0].elem0 = restore;
2747+ state.addr = 552446646280519680LLU; // copyu64___
2748+ break;
2749+ }
2750+ case 18446744073709551523LLU: // 999999998h'''''''''''''''
2751+ {
2752+ {
2753+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2754+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2755+
2756+ {
2757+ uint64_t arg = exchange;
2758+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2759+ }
2760+ }
2761+ // ACCUMULATE ARGUMENTS - END
2762+ uint64_t return_to = 18446744073709551526LLU;
2763+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
2764+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2765+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2766+ heap.data[0].elem1 = heap.data[0].elem0;
2767+ heap.data[0].elem0 = restore;
2768+ state.addr = 819859607768530944LLU; // resdest___
2769+ break;
2770+ }
2771+ case 18446744073709551526LLU: // 999999998k'''''''''''''''
2772+ {
2773+ // parameter-reference u64 reference_ goes out of scope
2774+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5
2775+ // parameter-reference u64 idx_______ goes out of scope
2776+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 4
2777+ // parameter-reference type______ type______ goes out of scope
2778+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 3
2779+ // parameter-reference resdest___ __________ goes out of scope
2780+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2781+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2782+ {
2783+ uint64_t baseinfo = heap.data[0].elem1;
2784+ struct pair pair = unpair(&heap, &baseinfo);
2785+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2786+ state.addr = pair.elem1;
2787+ }
2788+ break;
2789+ }
2790+ case 325737967258195136LLU: // REPORTRES_
2791+ {
2792+ {
2793+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 0LLU);
2794+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2795+ }
2796+ {
2797+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 1LLU);
2798+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2799+ }
2800+ {
2801+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 2LLU);
2802+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2803+ }
2804+ // ACCUMULATE ARGUMENTS - BEGIN
2805+ {
2806+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
2807+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2808+ }
2809+ // ACCUMULATE ARGUMENTS - END
2810+ uint64_t return_to = 18446744073709551521LLU;
2811+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2812+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2813+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2814+ heap.data[0].elem1 = heap.data[0].elem0;
2815+ heap.data[0].elem0 = restore;
2816+ state.addr = 819847183518878432LLU; // reporttype
2817+ break;
2818+ }
2819+ case 18446744073709551521LLU: // 999999998f'''''''''''''''
2820+ {
2821+ fprintf(stderr, "%s", " ");
2822+ fprintf(stderr, "%s", "(");
2823+ fprintf(stderr, "%llu", (unsigned long long)/*index_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)));
2824+ fprintf(stderr, "%s", ")");
2825+ // parameter-reference u64 reference_ goes out of scope
2826+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 4
2827+ // parameter-reference u64 index_____ goes out of scope
2828+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference index_____ at 3
2829+ // parameter-reference type______ type______ goes out of scope
2830+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 2
2831+ // parameter-reference resdest___ __________ goes out of scope
2832+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2833+ {
2834+ uint64_t baseinfo = heap.data[0].elem1;
2835+ struct pair pair = unpair(&heap, &baseinfo);
2836+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2837+ state.addr = pair.elem1;
2838+ }
2839+ break;
2840+ }
2841+ case 325737967258195155LLU: // REPORTRESS
2842+ {
2843+ fprintf(stderr, "%s", "(");
2844+ {
2845+ uint64_t arg = 0;
2846+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2847+ }
2848+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 1;
2849+ {
2850+ uint64_t arg = /*rs________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU));
2851+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2852+ }
2853+ {
2854+ uint64_t arg = 0;
2855+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2856+ }
2857+ state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
2858+ break;
2859+ }
2860+ case 18446744073709551520LLU: // 999999998e'''''''''''''''
2861+ {
2862+ if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
2863+ {
2864+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2865+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
2866+ {
2867+ state.addr = 18446744073709551519LLU; // 999999998d'''''''''''''''
2868+ break;
2869+ }
2870+ }
2871+ /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
2872+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
2873+ {
2874+ uint64_t arg = 0;
2875+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2876+ }
2877+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*first_____*/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU);
2878+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551518LLU : 18446744073709551517LLU;
2879+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
2880+ break;
2881+ }
2882+ case 18446744073709551518LLU: // 999999998c'''''''''''''''
2883+ {
2884+
2885+ *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = 0;
2886+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
2887+ break;
2888+ }
2889+ case 18446744073709551517LLU: // 999999998b'''''''''''''''
2890+ {
2891+ fprintf(stderr, "%s", ", ");
2892+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
2893+ break;
2894+ }
2895+ case 18446744073709551516LLU: // 999999998a'''''''''''''''
2896+ {
2897+ // ACCUMULATE ARGUMENTS - BEGIN
2898+ {
2899+ uint64_t arg = /*r_________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2900+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2901+ }
2902+ // ACCUMULATE ARGUMENTS - END
2903+ uint64_t return_to = 18446744073709551515LLU;
2904+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2905+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2906+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2907+ heap.data[0].elem1 = heap.data[0].elem0;
2908+ heap.data[0].elem0 = restore;
2909+ state.addr = 325737967258195136LLU; // REPORTRES_
2910+ break;
2911+ }
2912+ case 18446744073709551515LLU: // 999999998$'''''''''''''''
2913+ {
2914+ // parameter-reference resdest___ r_________ goes out of scope
2915+ // parameter-reference list<resdest___> rs________ goes out of scope
2916+ state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
2917+ break;
2918+ }
2919+ case 18446744073709551519LLU: // 999999998d'''''''''''''''
2920+ {
2921+ fprintf(stderr, "%s", ")");
2922+ // variable u64 first_____ goes out of scope
2923+ // emitted destructur for type u64
2924+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 2
2925+ // parameter-reference list<resdest___> rs________ goes out of scope
2926+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference rs________ at 1
2927+ {
2928+ uint64_t baseinfo = heap.data[0].elem1;
2929+ struct pair pair = unpair(&heap, &baseinfo);
2930+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2931+ state.addr = pair.elem1;
2932+ }
2933+ break;
2934+ }
2935+ case 18446744073709551513LLU: // 999999998Y'''''''''''''''
2936+ {
2937+ // destructor for variant maintain__
2938+ // RELEASE destructor-argument
2939+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2940+ {
2941+ uint64_t baseinfo = heap.data[0].elem1;
2942+ struct pair pair = unpair(&heap, &baseinfo);
2943+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2944+ state.addr = pair.elem1;
2945+ }
2946+ break;
2947+ }
2948+ case 18446744073709551512LLU: // 999999998X'''''''''''''''
2949+ {
2950+ // destructor for variant consume___
2951+ // RELEASE destructor-argument
2952+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2953+ {
2954+ uint64_t baseinfo = heap.data[0].elem1;
2955+ struct pair pair = unpair(&heap, &baseinfo);
2956+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2957+ state.addr = pair.elem1;
2958+ }
2959+ break;
2960+ }
2961+ case 18446744073709551514LLU: // 999999998Z'''''''''''''''
2962+ {
2963+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2964+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
2965+ state.addr = 18446744073709551512LLU + type_data.elem0;
2966+ break;
2967+ }
2968+ case 728618437845356544LLU: // maintain__
2969+ {
2970+ // union-constructor maintain__
2971+ {
2972+ uint64_t result_tuple = 0;
2973+ // copy references
2974+ // release parameters
2975+ {
2976+ uint64_t constridx = 1LLU;
2977+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
2978+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
2979+ }
2980+ }
2981+ {
2982+ uint64_t baseinfo = heap.data[0].elem1;
2983+ struct pair pair = unpair(&heap, &baseinfo);
2984+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2985+ state.addr = pair.elem1;
2986+ }
2987+ break;
2988+ }
2989+ case 552437437528276992LLU: // consume___
2990+ {
2991+ // union-constructor consume___
2992+ {
2993+ uint64_t result_tuple = 0;
2994+ // copy references
2995+ // release parameters
2996+ {
2997+ uint64_t constridx = 0LLU;
2998+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
2999+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3000+ }
3001+ }
3002+ {
3003+ uint64_t baseinfo = heap.data[0].elem1;
3004+ struct pair pair = unpair(&heap, &baseinfo);
3005+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3006+ state.addr = pair.elem1;
3007+ }
3008+ break;
3009+ }
3010+ case 589058781102643104LLU: // equbalance
3011+ {
3012+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*consume___*/)
3013+ {
3014+ state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
3015+ break;
3016+ }
3017+ {
3018+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3019+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3020+ }
3021+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*consume___*/)
3022+ {
3023+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3024+ state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
3025+ break;
3026+ }
3027+ {
3028+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3029+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3030+ }
3031+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3032+ // parameter-reference continuity __________ goes out of scope
3033+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3034+ // parameter continuity __________ goes out of scope
3035+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3036+ // parameter-reference continuity __________ goes out of scope
3037+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3038+ // parameter continuity __________ goes out of scope
3039+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3040+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3041+ {
3042+ uint64_t baseinfo = heap.data[0].elem1;
3043+ struct pair pair = unpair(&heap, &baseinfo);
3044+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3045+ state.addr = pair.elem1;
3046+ }
3047+ break;
3048+ }
3049+ case 18446744073709551511LLU: // 999999998W'''''''''''''''
3050+ {
3051+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*maintain__*/)
3052+ {
3053+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3054+ break;
3055+ }
3056+ {
3057+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3058+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3059+ }
3060+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*consume___*/)
3061+ {
3062+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3063+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3064+ break;
3065+ }
3066+ {
3067+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3068+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3069+ }
3070+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3071+ // parameter-reference continuity __________ goes out of scope
3072+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3073+ // parameter continuity __________ goes out of scope
3074+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3075+ // parameter-reference continuity __________ goes out of scope
3076+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3077+ // parameter continuity __________ goes out of scope
3078+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3079+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3080+ {
3081+ uint64_t baseinfo = heap.data[0].elem1;
3082+ struct pair pair = unpair(&heap, &baseinfo);
3083+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3084+ state.addr = pair.elem1;
3085+ }
3086+ break;
3087+ }
3088+ case 18446744073709551510LLU: // 999999998V'''''''''''''''
3089+ {
3090+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*consume___*/)
3091+ {
3092+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3093+ break;
3094+ }
3095+ {
3096+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3097+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3098+ }
3099+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*maintain__*/)
3100+ {
3101+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3102+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3103+ break;
3104+ }
3105+ {
3106+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3107+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3108+ }
3109+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3110+ // parameter-reference continuity __________ goes out of scope
3111+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3112+ // parameter continuity __________ goes out of scope
3113+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3114+ // parameter-reference continuity __________ goes out of scope
3115+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3116+ // parameter continuity __________ goes out of scope
3117+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3118+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3119+ {
3120+ uint64_t baseinfo = heap.data[0].elem1;
3121+ struct pair pair = unpair(&heap, &baseinfo);
3122+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3123+ state.addr = pair.elem1;
3124+ }
3125+ break;
3126+ }
3127+ case 18446744073709551509LLU: // 999999998U'''''''''''''''
3128+ {
3129+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*maintain__*/)
3130+ {
3131+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3132+ break;
3133+ }
3134+ {
3135+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3136+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3137+ }
3138+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*maintain__*/)
3139+ {
3140+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3141+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3142+ break;
3143+ }
3144+ {
3145+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3146+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3147+ }
3148+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3149+ // parameter-reference continuity __________ goes out of scope
3150+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3151+ // parameter continuity __________ goes out of scope
3152+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3153+ // parameter-reference continuity __________ goes out of scope
3154+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3155+ // parameter continuity __________ goes out of scope
3156+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3157+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3158+ {
3159+ uint64_t baseinfo = heap.data[0].elem1;
3160+ struct pair pair = unpair(&heap, &baseinfo);
3161+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3162+ state.addr = pair.elem1;
3163+ }
3164+ break;
3165+ }
3166+ case 18446744073709551508LLU: // 999999998T'''''''''''''''
3167+ {
3168+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equbalance\n");
3169+ exit(-1);
3170+ break;
3171+ }
3172+ case 58555672873677120LLU: // CPBALANCE_
3173+ {
3174+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*consume___*/)
3175+ {
3176+ state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
3177+ break;
3178+ }
3179+ {
3180+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3181+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3182+ }
3183+ // ACCUMULATE ARGUMENTS - BEGIN
3184+ {
3185+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3186+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3187+ }
3188+ // ACCUMULATE ARGUMENTS - END
3189+ uint64_t return_to = 18446744073709551506LLU;
3190+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3191+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3192+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3193+ heap.data[0].elem1 = heap.data[0].elem0;
3194+ heap.data[0].elem0 = restore;
3195+ state.addr = 552437437528276992LLU; // consume___
3196+ break;
3197+ }
3198+ case 18446744073709551506LLU: // 999999998R'''''''''''''''
3199+ {
3200+ // parameter-reference continuity __________ goes out of scope
3201+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3202+ // parameter continuity __________ goes out of scope
3203+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3204+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3205+ {
3206+ uint64_t baseinfo = heap.data[0].elem1;
3207+ struct pair pair = unpair(&heap, &baseinfo);
3208+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3209+ state.addr = pair.elem1;
3210+ }
3211+ break;
3212+ }
3213+ case 18446744073709551507LLU: // 999999998S'''''''''''''''
3214+ {
3215+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*maintain__*/)
3216+ {
3217+ state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3218+ break;
3219+ }
3220+ {
3221+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3222+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3223+ }
3224+ // ACCUMULATE ARGUMENTS - BEGIN
3225+ {
3226+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3227+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3228+ }
3229+ // ACCUMULATE ARGUMENTS - END
3230+ uint64_t return_to = 18446744073709551504LLU;
3231+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3232+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3233+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3234+ heap.data[0].elem1 = heap.data[0].elem0;
3235+ heap.data[0].elem0 = restore;
3236+ state.addr = 728618437845356544LLU; // maintain__
3237+ break;
3238+ }
3239+ case 18446744073709551504LLU: // 999999998P'''''''''''''''
3240+ {
3241+ // parameter-reference continuity __________ goes out of scope
3242+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3243+ // parameter continuity __________ goes out of scope
3244+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3245+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3246+ {
3247+ uint64_t baseinfo = heap.data[0].elem1;
3248+ struct pair pair = unpair(&heap, &baseinfo);
3249+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3250+ state.addr = pair.elem1;
3251+ }
3252+ break;
3253+ }
3254+ case 18446744073709551505LLU: // 999999998Q'''''''''''''''
3255+ {
3256+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CPBALANCE_\n");
3257+ exit(-1);
3258+ break;
3259+ }
3260+ case 18446744073709551502LLU: // 999999998N'''''''''''''''
3261+ {
3262+ // destructor for variant blkloop___
3263+ // RELEASE destructor-argument
3264+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3265+ {
3266+ uint64_t baseinfo = heap.data[0].elem1;
3267+ struct pair pair = unpair(&heap, &baseinfo);
3268+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3269+ state.addr = pair.elem1;
3270+ }
3271+ break;
3272+ }
3273+ case 18446744073709551501LLU: // 999999998M'''''''''''''''
3274+ {
3275+ // destructor for variant blkelse___
3276+ // RELEASE destructor-argument
3277+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3278+ {
3279+ uint64_t baseinfo = heap.data[0].elem1;
3280+ struct pair pair = unpair(&heap, &baseinfo);
3281+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3282+ state.addr = pair.elem1;
3283+ }
3284+ break;
3285+ }
3286+ case 18446744073709551500LLU: // 999999998L'''''''''''''''
3287+ {
3288+ // destructor for variant blkif_____
3289+ // RELEASE destructor-argument
3290+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3291+ {
3292+ uint64_t baseinfo = heap.data[0].elem1;
3293+ struct pair pair = unpair(&heap, &baseinfo);
3294+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3295+ state.addr = pair.elem1;
3296+ }
3297+ break;
3298+ }
3299+ case 18446744073709551499LLU: // 999999998K'''''''''''''''
3300+ {
3301+ // destructor for variant blkwhen___
3302+ // RELEASE destructor-argument
3303+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3304+ {
3305+ uint64_t baseinfo = heap.data[0].elem1;
3306+ struct pair pair = unpair(&heap, &baseinfo);
3307+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3308+ state.addr = pair.elem1;
3309+ }
3310+ break;
3311+ }
3312+ case 18446744073709551498LLU: // 999999998J'''''''''''''''
3313+ {
3314+ // destructor for variant blknone___
3315+ // RELEASE destructor-argument
3316+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3317+ {
3318+ uint64_t baseinfo = heap.data[0].elem1;
3319+ struct pair pair = unpair(&heap, &baseinfo);
3320+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3321+ state.addr = pair.elem1;
3322+ }
3323+ break;
3324+ }
3325+ case 18446744073709551503LLU: // 999999998O'''''''''''''''
3326+ {
3327+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3328+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
3329+ state.addr = 18446744073709551498LLU + type_data.elem0;
3330+ break;
3331+ }
3332+ case 533564932506779648LLU: // blkloop___
3333+ {
3334+ // union-constructor blkloop___
3335+ {
3336+ uint64_t result_tuple = 0;
3337+ // copy references
3338+ // release parameters
3339+ {
3340+ uint64_t constridx = 4LLU;
3341+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3342+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3343+ }
3344+ }
3345+ {
3346+ uint64_t baseinfo = heap.data[0].elem1;
3347+ struct pair pair = unpair(&heap, &baseinfo);
3348+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3349+ state.addr = pair.elem1;
3350+ }
3351+ break;
3352+ }
3353+ case 533564448313442304LLU: // blkelse___
3354+ {
3355+ // union-constructor blkelse___
3356+ {
3357+ uint64_t result_tuple = 0;
3358+ // copy references
3359+ // release parameters
3360+ {
3361+ uint64_t constridx = 3LLU;
3362+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3363+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3364+ }
3365+ }
3366+ {
3367+ uint64_t baseinfo = heap.data[0].elem1;
3368+ struct pair pair = unpair(&heap, &baseinfo);
3369+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3370+ state.addr = pair.elem1;
3371+ }
3372+ break;
3373+ }
3374+ case 533564715968757760LLU: // blkif_____
3375+ {
3376+ // union-constructor blkif_____
3377+ {
3378+ uint64_t result_tuple = 0;
3379+ // copy references
3380+ // release parameters
3381+ {
3382+ uint64_t constridx = 2LLU;
3383+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3384+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3385+ }
3386+ }
3387+ {
3388+ uint64_t baseinfo = heap.data[0].elem1;
3389+ struct pair pair = unpair(&heap, &baseinfo);
3390+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3391+ state.addr = pair.elem1;
3392+ }
3393+ break;
3394+ }
3395+ case 533565680736534528LLU: // blkwhen___
3396+ {
3397+ // union-constructor blkwhen___
3398+ {
3399+ uint64_t result_tuple = 0;
3400+ // copy references
3401+ // release parameters
3402+ {
3403+ uint64_t constridx = 1LLU;
3404+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3405+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3406+ }
3407+ }
3408+ {
3409+ uint64_t baseinfo = heap.data[0].elem1;
3410+ struct pair pair = unpair(&heap, &baseinfo);
3411+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3412+ state.addr = pair.elem1;
3413+ }
3414+ break;
3415+ }
3416+ case 533565069926072320LLU: // blknone___
3417+ {
3418+ // union-constructor blknone___
3419+ {
3420+ uint64_t result_tuple = 0;
3421+ // copy references
3422+ // release parameters
3423+ {
3424+ uint64_t constridx = 0LLU;
3425+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3426+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3427+ }
3428+ }
3429+ {
3430+ uint64_t baseinfo = heap.data[0].elem1;
3431+ struct pair pair = unpair(&heap, &baseinfo);
3432+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3433+ state.addr = pair.elem1;
3434+ }
3435+ break;
3436+ }
3437+ case 819847183514106240LLU: // reportblk_
3438+ {
3439+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*blknone___*/)
3440+ {
3441+ state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
3442+ break;
3443+ }
3444+ {
3445+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3446+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3447+ }
3448+ fprintf(stderr, "%s", "blknone");
3449+ // parameter-reference blockvar__ __________ goes out of scope
3450+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3451+ // parameter blockvar__ __________ goes out of scope
3452+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3453+ {
3454+ uint64_t baseinfo = heap.data[0].elem1;
3455+ struct pair pair = unpair(&heap, &baseinfo);
3456+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3457+ state.addr = pair.elem1;
3458+ }
3459+ break;
3460+ }
3461+ case 18446744073709551497LLU: // 999999998I'''''''''''''''
3462+ {
3463+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*blkwhen___*/)
3464+ {
3465+ state.addr = 18446744073709551496LLU; // 999999998H'''''''''''''''
3466+ break;
3467+ }
3468+ {
3469+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3470+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3471+ }
3472+ fprintf(stderr, "%s", "blkwhen");
3473+ // parameter-reference blockvar__ __________ goes out of scope
3474+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3475+ // parameter blockvar__ __________ goes out of scope
3476+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3477+ {
3478+ uint64_t baseinfo = heap.data[0].elem1;
3479+ struct pair pair = unpair(&heap, &baseinfo);
3480+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3481+ state.addr = pair.elem1;
3482+ }
3483+ break;
3484+ }
3485+ case 18446744073709551496LLU: // 999999998H'''''''''''''''
3486+ {
3487+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*blkif_____*/)
3488+ {
3489+ state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
3490+ break;
3491+ }
3492+ {
3493+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3494+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3495+ }
3496+ fprintf(stderr, "%s", "blkif");
3497+ // parameter-reference blockvar__ __________ goes out of scope
3498+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3499+ // parameter blockvar__ __________ goes out of scope
3500+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3501+ {
3502+ uint64_t baseinfo = heap.data[0].elem1;
3503+ struct pair pair = unpair(&heap, &baseinfo);
3504+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3505+ state.addr = pair.elem1;
3506+ }
3507+ break;
3508+ }
3509+ case 18446744073709551495LLU: // 999999998G'''''''''''''''
3510+ {
3511+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*blkelse___*/)
3512+ {
3513+ state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
3514+ break;
3515+ }
3516+ {
3517+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3518+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3519+ }
3520+ fprintf(stderr, "%s", "blkelse");
3521+ // parameter-reference blockvar__ __________ goes out of scope
3522+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3523+ // parameter blockvar__ __________ goes out of scope
3524+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3525+ {
3526+ uint64_t baseinfo = heap.data[0].elem1;
3527+ struct pair pair = unpair(&heap, &baseinfo);
3528+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3529+ state.addr = pair.elem1;
3530+ }
3531+ break;
3532+ }
3533+ case 18446744073709551494LLU: // 999999998F'''''''''''''''
3534+ {
3535+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*blkloop___*/)
3536+ {
3537+ state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
3538+ break;
3539+ }
3540+ {
3541+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3542+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3543+ }
3544+ fprintf(stderr, "%s", "blkloop");
3545+ // parameter-reference blockvar__ __________ goes out of scope
3546+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3547+ // parameter blockvar__ __________ goes out of scope
3548+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3549+ {
3550+ uint64_t baseinfo = heap.data[0].elem1;
3551+ struct pair pair = unpair(&heap, &baseinfo);
3552+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3553+ state.addr = pair.elem1;
3554+ }
3555+ break;
3556+ }
3557+ case 18446744073709551493LLU: // 999999998E'''''''''''''''
3558+ {
3559+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportblk_\n");
3560+ exit(-1);
3561+ break;
3562+ }
3563+ case 18446744073709551491LLU: // 999999998C'''''''''''''''
3564+ {
3565+ // destructor for variant varhide___
3566+ // RELEASE destructor-argument
3567+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3568+ {
3569+ uint64_t baseinfo = heap.data[0].elem1;
3570+ struct pair pair = unpair(&heap, &baseinfo);
3571+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3572+ state.addr = pair.elem1;
3573+ }
3574+ break;
3575+ }
3576+ case 18446744073709551490LLU: // 999999998B'''''''''''''''
3577+ {
3578+ // destructor for variant elblock___
3579+ {
3580+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3581+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3582+ }
3583+ // emitted destructur for type u64
3584+ // RELEASE temporary destructor-variable
3585+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3586+ // RELEASE destructor-argument
3587+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3588+ {
3589+ uint64_t baseinfo = heap.data[0].elem1;
3590+ struct pair pair = unpair(&heap, &baseinfo);
3591+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3592+ state.addr = pair.elem1;
3593+ }
3594+ break;
3595+ }
3596+ case 18446744073709551489LLU: // 999999998A'''''''''''''''
3597+ {
3598+ // destructor for variant varblock__
3599+ // RELEASE destructor-argument
3600+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3601+ {
3602+ uint64_t baseinfo = heap.data[0].elem1;
3603+ struct pair pair = unpair(&heap, &baseinfo);
3604+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3605+ state.addr = pair.elem1;
3606+ }
3607+ break;
3608+ }
3609+ case 18446744073709551488LLU: // 999999998_'''''''''''''''
3610+ {
3611+ // destructor for variant varvirt___
3612+ {
3613+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3614+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3615+ }
3616+ // emitted destructur for type u64
3617+ // RELEASE temporary destructor-variable
3618+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3619+ {
3620+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3621+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3622+ }
3623+ // emitted destructur for type u64
3624+ // RELEASE temporary destructor-variable
3625+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3626+ {
3627+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3628+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3629+ }
3630+ // emitted destructur for type type______
3631+ // ACCUMULATE ARGUMENTS - BEGIN
3632+ {
3633+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
3634+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3635+ }
3636+ // ACCUMULATE ARGUMENTS - END
3637+ uint64_t return_to = 18446744073709551485LLU;
3638+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3639+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3640+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3641+ heap.data[0].elem1 = heap.data[0].elem0;
3642+ heap.data[0].elem0 = restore;
3643+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3644+ break;
3645+ }
3646+ case 18446744073709551485LLU: // 9999999977'''''''''''''''
3647+ {
3648+ // RELEASE temporary destructor-variable
3649+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3650+ {
3651+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3652+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3653+ }
3654+ // emitted destructur for type u64
3655+ // RELEASE temporary destructor-variable
3656+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3657+ {
3658+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3659+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3660+ }
3661+ // emitted destructur for type u64
3662+ // RELEASE temporary destructor-variable
3663+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3664+ // RELEASE destructor-argument
3665+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3666+ {
3667+ uint64_t baseinfo = heap.data[0].elem1;
3668+ struct pair pair = unpair(&heap, &baseinfo);
3669+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3670+ state.addr = pair.elem1;
3671+ }
3672+ break;
3673+ }
3674+ case 18446744073709551487LLU: // 9999999979'''''''''''''''
3675+ {
3676+ // destructor for variant varref____
3677+ {
3678+ uint64_t arg = tree_pop_move(&heap, 6LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3679+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3680+ }
3681+ // emitted destructur for type u64
3682+ // RELEASE temporary destructor-variable
3683+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3684+ {
3685+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3686+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3687+ }
3688+ // emitted destructur for type u64
3689+ // RELEASE temporary destructor-variable
3690+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3691+ {
3692+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3693+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3694+ }
3695+ // emitted destructur for type u64
3696+ // RELEASE temporary destructor-variable
3697+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3698+ {
3699+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3700+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3701+ }
3702+ // emitted destructur for type type______
3703+ // ACCUMULATE ARGUMENTS - BEGIN
3704+ {
3705+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
3706+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3707+ }
3708+ // ACCUMULATE ARGUMENTS - END
3709+ uint64_t return_to = 18446744073709551484LLU;
3710+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3711+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3712+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3713+ heap.data[0].elem1 = heap.data[0].elem0;
3714+ heap.data[0].elem0 = restore;
3715+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3716+ break;
3717+ }
3718+ case 18446744073709551484LLU: // 9999999976'''''''''''''''
3719+ {
3720+ // RELEASE temporary destructor-variable
3721+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3722+ {
3723+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3724+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3725+ }
3726+ // emitted destructur for type u64
3727+ // RELEASE temporary destructor-variable
3728+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3729+ {
3730+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3731+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3732+ }
3733+ // emitted destructur for type u64
3734+ // RELEASE temporary destructor-variable
3735+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3736+ // RELEASE destructor-argument
3737+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3738+ {
3739+ uint64_t baseinfo = heap.data[0].elem1;
3740+ struct pair pair = unpair(&heap, &baseinfo);
3741+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3742+ state.addr = pair.elem1;
3743+ }
3744+ break;
3745+ }
3746+ case 18446744073709551486LLU: // 9999999978'''''''''''''''
3747+ {
3748+ // destructor for variant varvar____
3749+ {
3750+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3751+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3752+ }
3753+ // emitted destructur for type u64
3754+ // RELEASE temporary destructor-variable
3755+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3756+ {
3757+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3758+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3759+ }
3760+ // emitted destructur for type u64
3761+ // RELEASE temporary destructor-variable
3762+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3763+ {
3764+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3765+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3766+ }
3767+ // emitted destructur for type type______
3768+ // ACCUMULATE ARGUMENTS - BEGIN
3769+ {
3770+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
3771+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3772+ }
3773+ // ACCUMULATE ARGUMENTS - END
3774+ uint64_t return_to = 18446744073709551483LLU;
3775+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3776+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3777+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3778+ heap.data[0].elem1 = heap.data[0].elem0;
3779+ heap.data[0].elem0 = restore;
3780+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3781+ break;
3782+ }
3783+ case 18446744073709551483LLU: // 9999999975'''''''''''''''
3784+ {
3785+ // RELEASE temporary destructor-variable
3786+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3787+ {
3788+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3789+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3790+ }
3791+ // emitted destructur for type u64
3792+ // RELEASE temporary destructor-variable
3793+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3794+ {
3795+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3796+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3797+ }
3798+ // emitted destructur for type u64
3799+ // RELEASE temporary destructor-variable
3800+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3801+ // RELEASE destructor-argument
3802+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3803+ {
3804+ uint64_t baseinfo = heap.data[0].elem1;
3805+ struct pair pair = unpair(&heap, &baseinfo);
3806+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3807+ state.addr = pair.elem1;
3808+ }
3809+ break;
3810+ }
3811+ case 18446744073709551492LLU: // 999999998D'''''''''''''''
3812+ {
3813+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3814+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
3815+ state.addr = 18446744073709551486LLU + type_data.elem0;
3816+ break;
3817+ }
3818+ case 890787182770388992LLU: // varhide___
3819+ {
3820+ // union-constructor varhide___
3821+ {
3822+ uint64_t result_tuple = 0;
3823+ // copy references
3824+ // release parameters
3825+ {
3826+ uint64_t constridx = 5LLU;
3827+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3828+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3829+ }
3830+ }
3831+ {
3832+ uint64_t baseinfo = heap.data[0].elem1;
3833+ struct pair pair = unpair(&heap, &baseinfo);
3834+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3835+ state.addr = pair.elem1;
3836+ }
3837+ break;
3838+ }
3839+ case 587568545413988352LLU: // elblock___
3840+ {
3841+ // union-constructor elblock___
3842+ {
3843+ uint64_t result_tuple = 0;
3844+ // copy references
3845+ {
3846+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
3847+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
3848+ }
3849+ // release parameters
3850+ {
3851+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3852+ }
3853+ {
3854+ uint64_t constridx = 4LLU;
3855+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3856+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3857+ }
3858+ }
3859+ {
3860+ uint64_t baseinfo = heap.data[0].elem1;
3861+ struct pair pair = unpair(&heap, &baseinfo);
3862+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3863+ state.addr = pair.elem1;
3864+ }
3865+ break;
3866+ }
3867+ case 890786773858934784LLU: // varblock__
3868+ {
3869+ // union-constructor varblock__
3870+ {
3871+ uint64_t result_tuple = 0;
3872+ // copy references
3873+ // release parameters
3874+ {
3875+ uint64_t constridx = 3LLU;
3876+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3877+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3878+ }
3879+ }
3880+ {
3881+ uint64_t baseinfo = heap.data[0].elem1;
3882+ struct pair pair = unpair(&heap, &baseinfo);
3883+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3884+ state.addr = pair.elem1;
3885+ }
3886+ break;
3887+ }
3888+ case 890788145081876480LLU: // varvirt___
3889+ {
3890+ // union-constructor varvirt___
3891+ {
3892+ uint64_t result_tuple = 0;
3893+ // copy references
3894+ {
3895+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
3896+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
3897+ }
3898+ {
3899+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
3900+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
3901+ }
3902+ {
3903+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
3904+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
3905+ }
3906+ {
3907+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
3908+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
3909+ }
3910+ {
3911+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
3912+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
3913+ }
3914+ // release parameters
3915+ {
3916+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3917+ }
3918+ {
3919+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3920+ }
3921+ {
3922+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3923+ }
3924+ {
3925+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3926+ }
3927+ {
3928+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3929+ }
3930+ {
3931+ uint64_t constridx = 2LLU;
3932+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3933+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3934+ }
3935+ }
3936+ {
3937+ uint64_t baseinfo = heap.data[0].elem1;
3938+ struct pair pair = unpair(&heap, &baseinfo);
3939+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3940+ state.addr = pair.elem1;
3941+ }
3942+ break;
3943+ }
3944+ case 890787865695354880LLU: // varref____
3945+ {
3946+ // union-constructor varref____
3947+ {
3948+ uint64_t result_tuple = 0;
3949+ // copy references
3950+ {
3951+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 0LLU + 1);
3952+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
3953+ }
3954+ {
3955+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 1LLU + 1);
3956+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
3957+ }
3958+ {
3959+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 2LLU + 1);
3960+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
3961+ }
3962+ {
3963+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 3LLU + 1);
3964+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
3965+ }
3966+ {
3967+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 4LLU + 1);
3968+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
3969+ }
3970+ {
3971+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 5LLU + 1);
3972+ tree_push_move(&heap, 5LLU, &result_tuple, &elem);
3973+ }
3974+ // release parameters
3975+ {
3976+ (void)LOCAL_POP_MOVE(&heap, 6LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3977+ }
3978+ {
3979+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3980+ }
3981+ {
3982+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3983+ }
3984+ {
3985+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3986+ }
3987+ {
3988+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3989+ }
3990+ {
3991+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
3992+ }
3993+ {
3994+ uint64_t constridx = 1LLU;
3995+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3996+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3997+ }
3998+ }
3999+ {
4000+ uint64_t baseinfo = heap.data[0].elem1;
4001+ struct pair pair = unpair(&heap, &baseinfo);
4002+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4003+ state.addr = pair.elem1;
4004+ }
4005+ break;
4006+ }
4007+ case 890788136479621120LLU: // varvar____
4008+ {
4009+ // union-constructor varvar____
4010+ {
4011+ uint64_t result_tuple = 0;
4012+ // copy references
4013+ {
4014+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4015+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4016+ }
4017+ {
4018+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4019+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4020+ }
4021+ {
4022+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4023+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4024+ }
4025+ {
4026+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4027+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4028+ }
4029+ {
4030+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4031+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4032+ }
4033+ // release parameters
4034+ {
4035+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4036+ }
4037+ {
4038+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4039+ }
4040+ {
4041+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4042+ }
4043+ {
4044+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4045+ }
4046+ {
4047+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4048+ }
4049+ {
4050+ uint64_t constridx = 0LLU;
4051+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4052+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4053+ }
4054+ }
4055+ {
4056+ uint64_t baseinfo = heap.data[0].elem1;
4057+ struct pair pair = unpair(&heap, &baseinfo);
4058+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4059+ state.addr = pair.elem1;
4060+ }
4061+ break;
4062+ }
4063+ case 819847183519304512LLU: // reportvar_
4064+ {
4065+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*varvar____*/)
4066+ {
4067+ state.addr = 18446744073709551482LLU; // 9999999974'''''''''''''''
4068+ break;
4069+ }
4070+ {
4071+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4072+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4073+ }
4074+ fprintf(stderr, "%s", "varvar");
4075+ // parameter-reference varkind___ __________ goes out of scope
4076+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4077+ // parameter varkind___ __________ goes out of scope
4078+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4079+ {
4080+ uint64_t baseinfo = heap.data[0].elem1;
4081+ struct pair pair = unpair(&heap, &baseinfo);
4082+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4083+ state.addr = pair.elem1;
4084+ }
4085+ break;
4086+ }
4087+ case 18446744073709551482LLU: // 9999999974'''''''''''''''
4088+ {
4089+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*varref____*/)
4090+ {
4091+ state.addr = 18446744073709551481LLU; // 9999999973'''''''''''''''
4092+ break;
4093+ }
4094+ {
4095+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4096+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4097+ }
4098+ fprintf(stderr, "%s", "varref");
4099+ // parameter-reference varkind___ __________ goes out of scope
4100+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4101+ // parameter varkind___ __________ goes out of scope
4102+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4103+ {
4104+ uint64_t baseinfo = heap.data[0].elem1;
4105+ struct pair pair = unpair(&heap, &baseinfo);
4106+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4107+ state.addr = pair.elem1;
4108+ }
4109+ break;
4110+ }
4111+ case 18446744073709551481LLU: // 9999999973'''''''''''''''
4112+ {
4113+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*varvirt___*/)
4114+ {
4115+ state.addr = 18446744073709551480LLU; // 9999999972'''''''''''''''
4116+ break;
4117+ }
4118+ {
4119+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4120+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4121+ }
4122+ fprintf(stderr, "%s", "varvirt");
4123+ // parameter-reference varkind___ __________ goes out of scope
4124+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4125+ // parameter varkind___ __________ goes out of scope
4126+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4127+ {
4128+ uint64_t baseinfo = heap.data[0].elem1;
4129+ struct pair pair = unpair(&heap, &baseinfo);
4130+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4131+ state.addr = pair.elem1;
4132+ }
4133+ break;
4134+ }
4135+ case 18446744073709551480LLU: // 9999999972'''''''''''''''
4136+ {
4137+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*varblock__*/)
4138+ {
4139+ state.addr = 18446744073709551479LLU; // 9999999971'''''''''''''''
4140+ break;
4141+ }
4142+ {
4143+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4144+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4145+ }
4146+ fprintf(stderr, "%s", "varblock");
4147+ // parameter-reference varkind___ __________ goes out of scope
4148+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4149+ // parameter varkind___ __________ goes out of scope
4150+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4151+ {
4152+ uint64_t baseinfo = heap.data[0].elem1;
4153+ struct pair pair = unpair(&heap, &baseinfo);
4154+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4155+ state.addr = pair.elem1;
4156+ }
4157+ break;
4158+ }
4159+ case 18446744073709551479LLU: // 9999999971'''''''''''''''
4160+ {
4161+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*elblock___*/)
4162+ {
4163+ state.addr = 18446744073709551478LLU; // 9999999970'''''''''''''''
4164+ break;
4165+ }
4166+ {
4167+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4168+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4169+ }
4170+ fprintf(stderr, "%s", "elblock");
4171+ // parameter-reference varkind___ __________ goes out of scope
4172+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4173+ // parameter varkind___ __________ goes out of scope
4174+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4175+ {
4176+ uint64_t baseinfo = heap.data[0].elem1;
4177+ struct pair pair = unpair(&heap, &baseinfo);
4178+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4179+ state.addr = pair.elem1;
4180+ }
4181+ break;
4182+ }
4183+ case 18446744073709551478LLU: // 9999999970'''''''''''''''
4184+ {
4185+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 5/*varhide___*/)
4186+ {
4187+ state.addr = 18446744073709551477LLU; // 999999997z'''''''''''''''
4188+ break;
4189+ }
4190+ {
4191+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4192+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4193+ }
4194+ fprintf(stderr, "%s", "varhide");
4195+ // parameter-reference varkind___ __________ goes out of scope
4196+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4197+ // parameter varkind___ __________ goes out of scope
4198+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4199+ {
4200+ uint64_t baseinfo = heap.data[0].elem1;
4201+ struct pair pair = unpair(&heap, &baseinfo);
4202+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4203+ state.addr = pair.elem1;
4204+ }
4205+ break;
4206+ }
4207+ case 18446744073709551477LLU: // 999999997z'''''''''''''''
4208+ {
4209+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportvar_\n");
4210+ exit(-1);
4211+ break;
4212+ }
4213+ case 18446744073709551476LLU: // 999999997y'''''''''''''''
4214+ {
4215+ {
4216+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4217+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4218+ }
4219+ // emitted destructur for type u64
4220+ // RELEASE temporary destructor-variable
4221+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4222+ {
4223+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4224+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4225+ }
4226+ // emitted destructur for type continuity
4227+ // ACCUMULATE ARGUMENTS - BEGIN
4228+ {
4229+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4230+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4231+ }
4232+ // ACCUMULATE ARGUMENTS - END
4233+ uint64_t return_to = 18446744073709551475LLU;
4234+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4235+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4236+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4237+ heap.data[0].elem1 = heap.data[0].elem0;
4238+ heap.data[0].elem0 = restore;
4239+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4240+ break;
4241+ }
4242+ case 18446744073709551475LLU: // 999999997x'''''''''''''''
4243+ {
4244+ // RELEASE temporary destructor-variable
4245+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4246+ {
4247+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4248+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4249+ }
4250+ // emitted destructur for type u64
4251+ // RELEASE temporary destructor-variable
4252+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4253+ {
4254+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4255+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4256+ }
4257+ // emitted destructur for type type______
4258+ // ACCUMULATE ARGUMENTS - BEGIN
4259+ {
4260+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4261+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4262+ }
4263+ // ACCUMULATE ARGUMENTS - END
4264+ uint64_t return_to = 18446744073709551474LLU;
4265+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4266+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4267+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4268+ heap.data[0].elem1 = heap.data[0].elem0;
4269+ heap.data[0].elem0 = restore;
4270+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4271+ break;
4272+ }
4273+ case 18446744073709551474LLU: // 999999997w'''''''''''''''
4274+ {
4275+ // RELEASE temporary destructor-variable
4276+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4277+ // RELEASE destructor-argument
4278+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4279+ {
4280+ uint64_t baseinfo = heap.data[0].elem1;
4281+ struct pair pair = unpair(&heap, &baseinfo);
4282+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4283+ state.addr = pair.elem1;
4284+ }
4285+ break;
4286+ }
4287+ case 782700512565788672LLU: // pardef____
4288+ {
4289+ // struct-constructor pardef____
4290+ {
4291+ uint64_t result_tuple = 0;
4292+ // copy references
4293+ {
4294+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 0LLU + 1);
4295+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4296+ }
4297+ {
4298+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 1LLU + 1);
4299+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4300+ }
4301+ {
4302+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 2LLU + 1);
4303+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4304+ }
4305+ {
4306+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 3LLU + 1);
4307+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4308+ }
4309+ // release parameters
4310+ {
4311+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4312+ }
4313+ {
4314+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4315+ }
4316+ {
4317+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4318+ }
4319+ {
4320+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4321+ }
4322+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4323+ }
4324+ {
4325+ uint64_t baseinfo = heap.data[0].elem1;
4326+ struct pair pair = unpair(&heap, &baseinfo);
4327+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4328+ state.addr = pair.elem1;
4329+ }
4330+ break;
4331+ }
4332+ case 18446744073709551473LLU: // 999999997v'''''''''''''''
4333+ {
4334+ {
4335+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4336+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4337+ }
4338+ // emitted destructur for type type______
4339+ // ACCUMULATE ARGUMENTS - BEGIN
4340+ {
4341+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4342+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4343+ }
4344+ // ACCUMULATE ARGUMENTS - END
4345+ uint64_t return_to = 18446744073709551472LLU;
4346+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4347+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4348+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4349+ heap.data[0].elem1 = heap.data[0].elem0;
4350+ heap.data[0].elem0 = restore;
4351+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4352+ break;
4353+ }
4354+ case 18446744073709551472LLU: // 999999997u'''''''''''''''
4355+ {
4356+ // RELEASE temporary destructor-variable
4357+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4358+ {
4359+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4360+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4361+ }
4362+ // emitted destructur for type u64
4363+ // RELEASE temporary destructor-variable
4364+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4365+ // RELEASE destructor-argument
4366+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4367+ {
4368+ uint64_t baseinfo = heap.data[0].elem1;
4369+ struct pair pair = unpair(&heap, &baseinfo);
4370+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4371+ state.addr = pair.elem1;
4372+ }
4373+ break;
4374+ }
4375+ case 587581796494082048LLU: // elemdef___
4376+ {
4377+ // struct-constructor elemdef___
4378+ {
4379+ uint64_t result_tuple = 0;
4380+ // copy references
4381+ {
4382+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 0LLU + 1);
4383+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4384+ }
4385+ {
4386+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 1LLU + 1);
4387+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4388+ }
4389+ // release parameters
4390+ {
4391+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4392+ }
4393+ {
4394+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4395+ }
4396+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4397+ }
4398+ {
4399+ uint64_t baseinfo = heap.data[0].elem1;
4400+ struct pair pair = unpair(&heap, &baseinfo);
4401+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4402+ state.addr = pair.elem1;
4403+ }
4404+ break;
4405+ }
4406+ case 18446744073709551471LLU: // 999999997t'''''''''''''''
4407+ {
4408+ {
4409+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4410+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4411+ }
4412+ // emitted destructur for type u64
4413+ // RELEASE temporary destructor-variable
4414+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4415+ {
4416+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4417+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4418+ }
4419+ // emitted destructur for type type______
4420+ // ACCUMULATE ARGUMENTS - BEGIN
4421+ {
4422+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4423+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4424+ }
4425+ // ACCUMULATE ARGUMENTS - END
4426+ uint64_t return_to = 18446744073709551470LLU;
4427+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4428+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4429+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4430+ heap.data[0].elem1 = heap.data[0].elem0;
4431+ heap.data[0].elem0 = restore;
4432+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4433+ break;
4434+ }
4435+ case 18446744073709551470LLU: // 999999997s'''''''''''''''
4436+ {
4437+ // RELEASE temporary destructor-variable
4438+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4439+ {
4440+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4441+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4442+ }
4443+ // emitted destructur for type u64
4444+ // RELEASE temporary destructor-variable
4445+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4446+ {
4447+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4448+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4449+ }
4450+ // emitted destructur for type continuity
4451+ // ACCUMULATE ARGUMENTS - BEGIN
4452+ {
4453+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4454+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4455+ }
4456+ // ACCUMULATE ARGUMENTS - END
4457+ uint64_t return_to = 18446744073709551469LLU;
4458+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4459+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4460+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4461+ heap.data[0].elem1 = heap.data[0].elem0;
4462+ heap.data[0].elem0 = restore;
4463+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4464+ break;
4465+ }
4466+ case 18446744073709551469LLU: // 999999997r'''''''''''''''
4467+ {
4468+ // RELEASE temporary destructor-variable
4469+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4470+ {
4471+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4472+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4473+ }
4474+ // emitted destructur for type u64
4475+ // RELEASE temporary destructor-variable
4476+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4477+ // RELEASE destructor-argument
4478+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4479+ {
4480+ uint64_t baseinfo = heap.data[0].elem1;
4481+ struct pair pair = unpair(&heap, &baseinfo);
4482+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4483+ state.addr = pair.elem1;
4484+ }
4485+ break;
4486+ }
4487+ case 838947815509196800LLU: // signdef___
4488+ {
4489+ // struct-constructor signdef___
4490+ {
4491+ uint64_t result_tuple = 0;
4492+ // copy references
4493+ {
4494+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4495+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4496+ }
4497+ {
4498+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4499+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4500+ }
4501+ {
4502+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4503+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4504+ }
4505+ {
4506+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4507+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4508+ }
4509+ {
4510+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4511+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4512+ }
4513+ // release parameters
4514+ {
4515+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4516+ }
4517+ {
4518+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4519+ }
4520+ {
4521+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4522+ }
4523+ {
4524+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4525+ }
4526+ {
4527+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4528+ }
4529+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4530+ }
4531+ {
4532+ uint64_t baseinfo = heap.data[0].elem1;
4533+ struct pair pair = unpair(&heap, &baseinfo);
4534+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4535+ state.addr = pair.elem1;
4536+ }
4537+ break;
4538+ }
4539+ case 552740200527038528LLU: // cpsigndef_
4540+ {
4541+ {
4542+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
4543+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4544+ }
4545+ {
4546+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
4547+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4548+ }
4549+ {
4550+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
4551+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4552+ }
4553+ {
4554+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
4555+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4556+ }
4557+ {
4558+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU), 4LLU);
4559+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4560+ }
4561+ {
4562+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 0LLU);
4563+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4564+ }
4565+ {
4566+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 1LLU);
4567+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4568+ }
4569+ {
4570+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 2LLU);
4571+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4572+ }
4573+ {
4574+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 3LLU);
4575+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4576+ }
4577+ {
4578+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 11LLU, 1LLU), 4LLU);
4579+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4580+ }
4581+
4582+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 2LLU)) = /*indirect1_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 7LLU));
4583+
4584+ // emitted destructur for type continuity
4585+ // ACCUMULATE ARGUMENTS - BEGIN
4586+ {
4587+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
4588+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4589+ }
4590+ // ACCUMULATE ARGUMENTS - END
4591+ uint64_t return_to = 18446744073709551467LLU;
4592+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4593+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4594+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4595+ heap.data[0].elem1 = heap.data[0].elem0;
4596+ heap.data[0].elem0 = restore;
4597+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4598+ break;
4599+ }
4600+ case 18446744073709551467LLU: // 999999997p'''''''''''''''
4601+ {
4602+ // ACCUMULATE ARGUMENTS - BEGIN
4603+ {
4604+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
4605+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4606+ }
4607+ {
4608+ uint64_t arg = /*cont1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU);
4609+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4610+ }
4611+ // ACCUMULATE ARGUMENTS - END
4612+ uint64_t return_to = 18446744073709551466LLU;
4613+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4614+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4615+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4616+ heap.data[0].elem1 = heap.data[0].elem0;
4617+ heap.data[0].elem0 = restore;
4618+ state.addr = 58555672873677120LLU; // CPBALANCE_
4619+ break;
4620+ }
4621+ case 18446744073709551466LLU: // 999999997o'''''''''''''''
4622+ {
4623+
4624+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 4LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 9LLU));
4625+
4626+ // emitted destructur for type type______
4627+ // ACCUMULATE ARGUMENTS - BEGIN
4628+ {
4629+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
4630+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4631+ }
4632+ // ACCUMULATE ARGUMENTS - END
4633+ uint64_t return_to = 18446744073709551465LLU;
4634+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4635+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4636+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4637+ heap.data[0].elem1 = heap.data[0].elem0;
4638+ heap.data[0].elem0 = restore;
4639+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4640+ break;
4641+ }
4642+ case 18446744073709551465LLU: // 999999997n'''''''''''''''
4643+ {
4644+ // ACCUMULATE ARGUMENTS - BEGIN
4645+ {
4646+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
4647+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4648+ }
4649+ {
4650+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU);
4651+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4652+ }
4653+ // ACCUMULATE ARGUMENTS - END
4654+ uint64_t return_to = 18446744073709551464LLU;
4655+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4656+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4657+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4658+ heap.data[0].elem1 = heap.data[0].elem0;
4659+ heap.data[0].elem0 = restore;
4660+ state.addr = 367395560426147840LLU; // TYPECOPY__
4661+ break;
4662+ }
4663+ case 18446744073709551464LLU: // 999999997m'''''''''''''''
4664+ {
4665+
4666+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 6LLU)) = /*curidx1___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 11LLU));
4667+ // parameter-reference u64 curidx1___ goes out of scope
4668+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx1___ at 12
4669+ // parameter-reference type______ type1_____ goes out of scope
4670+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 11
4671+ // parameter-reference u64 mutable1__ goes out of scope
4672+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 10
4673+ // parameter-reference continuity cont1_____ goes out of scope
4674+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont1_____ at 9
4675+ // parameter-reference u64 indirect1_ goes out of scope
4676+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect1_ at 8
4677+ // parameter-reference signdef___ __________ goes out of scope
4678+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 7
4679+ // parameter-reference u64 curidx0___ goes out of scope
4680+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx0___ at 6
4681+ // parameter-reference type______ type0_____ goes out of scope
4682+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 5
4683+ // parameter-reference u64 mutable0__ goes out of scope
4684+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 4
4685+ // parameter-reference continuity cont0_____ goes out of scope
4686+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont0_____ at 3
4687+ // parameter-reference u64 indirect0_ goes out of scope
4688+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect0_ at 2
4689+ // parameter-reference signdef___ __________ goes out of scope
4690+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4691+ {
4692+ uint64_t baseinfo = heap.data[0].elem1;
4693+ struct pair pair = unpair(&heap, &baseinfo);
4694+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4695+ state.addr = pair.elem1;
4696+ }
4697+ break;
4698+ }
4699+ case 589059743276730432LLU: // equpardef_
4700+ {
4701+
4702+ // ACCUMULATE ARGUMENTS - BEGIN
4703+ {
4704+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
4705+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4706+ }
4707+ {
4708+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
4709+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4710+ }
4711+ {
4712+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
4713+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4714+ }
4715+ // ACCUMULATE ARGUMENTS - END
4716+ uint64_t return_to = 18446744073709551463LLU;
4717+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4718+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4719+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4720+ heap.data[0].elem1 = heap.data[0].elem0;
4721+ heap.data[0].elem0 = restore;
4722+ state.addr = 589060043891015680LLU; // equtype___
4723+ break;
4724+ }
4725+ case 18446744073709551463LLU: // 999999997l'''''''''''''''
4726+ {
4727+ {
4728+ uint64_t arg = 0;
4729+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4730+ }
4731+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4732+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551462LLU : 18446744073709551461LLU;
4733+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4734+ break;
4735+ }
4736+ case 18446744073709551462LLU: // 999999997k'''''''''''''''
4737+ {
4738+ state.addr = 18446744073709551460LLU; // 999999997i'''''''''''''''
4739+ break;
4740+ }
4741+ case 18446744073709551461LLU: // 999999997j'''''''''''''''
4742+ {
4743+ fprintf(stderr, "%s", "type");
4744+ state.addr = 18446744073709551460LLU; // 999999997i'''''''''''''''
4745+ break;
4746+ }
4747+ case 18446744073709551460LLU: // 999999997i'''''''''''''''
4748+ {
4749+ {
4750+ uint64_t arg = 0;
4751+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4752+ }
4753+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4754+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551459LLU : 18446744073709551458LLU;
4755+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4756+ break;
4757+ }
4758+ case 18446744073709551459LLU: // 999999997h'''''''''''''''
4759+ {
4760+
4761+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU));
4762+ {
4763+ uint64_t arg = 0;
4764+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4765+ }
4766+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4767+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551457LLU : 18446744073709551456LLU;
4768+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4769+ break;
4770+ }
4771+ case 18446744073709551457LLU: // 999999997f'''''''''''''''
4772+ {
4773+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
4774+ break;
4775+ }
4776+ case 18446744073709551456LLU: // 999999997e'''''''''''''''
4777+ {
4778+ fprintf(stderr, "%s", "mutable");
4779+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
4780+ break;
4781+ }
4782+ case 18446744073709551455LLU: // 999999997d'''''''''''''''
4783+ {
4784+ {
4785+ uint64_t arg = 0;
4786+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4787+ }
4788+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4789+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551454LLU : 18446744073709551453LLU;
4790+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4791+ break;
4792+ }
4793+ case 18446744073709551454LLU: // 999999997c'''''''''''''''
4794+ {
4795+
4796+ // ACCUMULATE ARGUMENTS - BEGIN
4797+ {
4798+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
4799+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4800+ }
4801+ {
4802+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU);
4803+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4804+ }
4805+ {
4806+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU);
4807+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4808+ }
4809+ // ACCUMULATE ARGUMENTS - END
4810+ uint64_t return_to = 18446744073709551452LLU;
4811+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4812+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4813+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4814+ heap.data[0].elem1 = heap.data[0].elem0;
4815+ heap.data[0].elem0 = restore;
4816+ state.addr = 589058781102643104LLU; // equbalance
4817+ break;
4818+ }
4819+ case 18446744073709551452LLU: // 999999997a'''''''''''''''
4820+ {
4821+ {
4822+ uint64_t arg = 0;
4823+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4824+ }
4825+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4826+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551451LLU : 18446744073709551450LLU;
4827+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4828+ break;
4829+ }
4830+ case 18446744073709551451LLU: // 999999997$'''''''''''''''
4831+ {
4832+ state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
4833+ break;
4834+ }
4835+ case 18446744073709551450LLU: // 999999997Z'''''''''''''''
4836+ {
4837+ fprintf(stderr, "%s", "continuity");
4838+ state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
4839+ break;
4840+ }
4841+ case 18446744073709551449LLU: // 999999997Y'''''''''''''''
4842+ {
4843+ {
4844+ uint64_t arg = 0;
4845+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4846+ }
4847+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4848+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551448LLU : 18446744073709551447LLU;
4849+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4850+ break;
4851+ }
4852+ case 18446744073709551448LLU: // 999999997X'''''''''''''''
4853+ {
4854+
4855+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 3LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 3LLU));
4856+ {
4857+ uint64_t arg = 0;
4858+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4859+ }
4860+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4861+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551446LLU : 18446744073709551445LLU;
4862+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4863+ break;
4864+ }
4865+ case 18446744073709551446LLU: // 999999997V'''''''''''''''
4866+ {
4867+ state.addr = 18446744073709551444LLU; // 999999997T'''''''''''''''
4868+ break;
4869+ }
4870+ case 18446744073709551445LLU: // 999999997U'''''''''''''''
4871+ {
4872+ fprintf(stderr, "%s", "REFERENCE");
4873+ state.addr = 18446744073709551444LLU; // 999999997T'''''''''''''''
4874+ break;
4875+ }
4876+ case 18446744073709551444LLU: // 999999997T'''''''''''''''
4877+ {
4878+ state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
4879+ break;
4880+ }
4881+ case 18446744073709551447LLU: // 999999997W'''''''''''''''
4882+ {
4883+ state.addr = 18446744073709551453LLU; // 999999997b'''''''''''''''
4884+ break;
4885+ }
4886+ case 18446744073709551453LLU: // 999999997b'''''''''''''''
4887+ {
4888+ state.addr = 18446744073709551458LLU; // 999999997g'''''''''''''''
4889+ break;
4890+ }
4891+ case 18446744073709551458LLU: // 999999997g'''''''''''''''
4892+ {
4893+ // parameter-reference pardef____ y_________ goes out of scope
4894+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
4895+ // parameter-reference pardef____ x_________ goes out of scope
4896+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
4897+ // parameter-reference u64 equal_____ goes out of scope
4898+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
4899+ {
4900+ uint64_t baseinfo = heap.data[0].elem1;
4901+ struct pair pair = unpair(&heap, &baseinfo);
4902+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4903+ state.addr = pair.elem1;
4904+ }
4905+ break;
4906+ }
4907+ case 589058998957897761LLU: // equelemdef
4908+ {
4909+
4910+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU));
4911+ {
4912+ uint64_t arg = 0;
4913+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4914+ }
4915+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
4916+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551443LLU : 18446744073709551442LLU;
4917+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
4918+ break;
4919+ }
4920+ case 18446744073709551443LLU: // 999999997S'''''''''''''''
4921+ {
4922+
4923+ // ACCUMULATE ARGUMENTS - BEGIN
4924+ {
4925+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
4926+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4927+ }
4928+ {
4929+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
4930+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4931+ }
4932+ {
4933+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU);
4934+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4935+ }
4936+ // ACCUMULATE ARGUMENTS - END
4937+ uint64_t return_to = 18446744073709551441LLU;
4938+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4939+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4940+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4941+ heap.data[0].elem1 = heap.data[0].elem0;
4942+ heap.data[0].elem0 = restore;
4943+ state.addr = 589060043891015680LLU; // equtype___
4944+ break;
4945+ }
4946+ case 18446744073709551441LLU: // 999999997Q'''''''''''''''
4947+ {
4948+ state.addr = 18446744073709551442LLU; // 999999997R'''''''''''''''
4949+ break;
4950+ }
4951+ case 18446744073709551442LLU: // 999999997R'''''''''''''''
4952+ {
4953+ // parameter-reference elemdef___ y_________ goes out of scope
4954+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
4955+ // parameter-reference elemdef___ x_________ goes out of scope
4956+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
4957+ // parameter-reference u64 equal_____ goes out of scope
4958+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
4959+ {
4960+ uint64_t baseinfo = heap.data[0].elem1;
4961+ struct pair pair = unpair(&heap, &baseinfo);
4962+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4963+ state.addr = pair.elem1;
4964+ }
4965+ break;
4966+ }
4967+ case 782700512573827828LLU: // pardefcopy
4968+ {
4969+ {
4970+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
4971+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4972+ }
4973+ {
4974+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
4975+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4976+ }
4977+ {
4978+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
4979+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4980+ }
4981+ {
4982+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
4983+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4984+ }
4985+ {
4986+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU);
4987+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4988+ }
4989+ {
4990+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU);
4991+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4992+ }
4993+ {
4994+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU);
4995+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4996+ }
4997+ {
4998+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU);
4999+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5000+ }
5001+
5002+ // emitted destructur for type type______
5003+ // ACCUMULATE ARGUMENTS - BEGIN
5004+ {
5005+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5006+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5007+ }
5008+ // ACCUMULATE ARGUMENTS - END
5009+ uint64_t return_to = 18446744073709551439LLU;
5010+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5011+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5012+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5013+ heap.data[0].elem1 = heap.data[0].elem0;
5014+ heap.data[0].elem0 = restore;
5015+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5016+ break;
5017+ }
5018+ case 18446744073709551439LLU: // 999999997O'''''''''''''''
5019+ {
5020+ // ACCUMULATE ARGUMENTS - BEGIN
5021+ {
5022+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5023+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5024+ }
5025+ {
5026+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
5027+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5028+ }
5029+ // ACCUMULATE ARGUMENTS - END
5030+ uint64_t return_to = 18446744073709551438LLU;
5031+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5032+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5033+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5034+ heap.data[0].elem1 = heap.data[0].elem0;
5035+ heap.data[0].elem0 = restore;
5036+ state.addr = 367395560426147840LLU; // TYPECOPY__
5037+ break;
5038+ }
5039+ case 18446744073709551438LLU: // 999999997N'''''''''''''''
5040+ {
5041+
5042+ // emitted destructur for type continuity
5043+ // ACCUMULATE ARGUMENTS - BEGIN
5044+ {
5045+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5046+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5047+ }
5048+ // ACCUMULATE ARGUMENTS - END
5049+ uint64_t return_to = 18446744073709551437LLU;
5050+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5051+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5052+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5053+ heap.data[0].elem1 = heap.data[0].elem0;
5054+ heap.data[0].elem0 = restore;
5055+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
5056+ break;
5057+ }
5058+ case 18446744073709551437LLU: // 999999997M'''''''''''''''
5059+ {
5060+ // ACCUMULATE ARGUMENTS - BEGIN
5061+ {
5062+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5063+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5064+ }
5065+ {
5066+ uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
5067+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5068+ }
5069+ // ACCUMULATE ARGUMENTS - END
5070+ uint64_t return_to = 18446744073709551436LLU;
5071+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5072+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5073+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5074+ heap.data[0].elem1 = heap.data[0].elem0;
5075+ heap.data[0].elem0 = restore;
5076+ state.addr = 58555672873677120LLU; // CPBALANCE_
5077+ break;
5078+ }
5079+ case 18446744073709551436LLU: // 999999997L'''''''''''''''
5080+ {
5081+
5082+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU));
5083+
5084+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
5085+ // parameter-reference u64 reference1 goes out of scope
5086+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 10
5087+ // parameter-reference continuity balance1__ goes out of scope
5088+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 9
5089+ // parameter-reference u64 mutable1__ goes out of scope
5090+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 8
5091+ // parameter-reference type______ type1_____ goes out of scope
5092+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 7
5093+ // parameter-reference pardef____ __________ goes out of scope
5094+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
5095+ // parameter-reference u64 reference0 goes out of scope
5096+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 5
5097+ // parameter-reference continuity balance0__ goes out of scope
5098+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance0__ at 4
5099+ // parameter-reference u64 mutable0__ goes out of scope
5100+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 3
5101+ // parameter-reference type______ type0_____ goes out of scope
5102+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2
5103+ // parameter-reference pardef____ __________ goes out of scope
5104+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5105+ {
5106+ uint64_t baseinfo = heap.data[0].elem1;
5107+ struct pair pair = unpair(&heap, &baseinfo);
5108+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5109+ state.addr = pair.elem1;
5110+ }
5111+ break;
5112+ }
5113+ case 296309897384864500LLU: // ParDefCopy
5114+ {
5115+ {
5116+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5117+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5118+ }
5119+ {
5120+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5121+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5122+ }
5123+ {
5124+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
5125+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5126+ }
5127+ {
5128+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU);
5129+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5130+ }
5131+ // ACCUMULATE ARGUMENTS - BEGIN
5132+ {
5133+ uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU);
5134+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5135+ }
5136+ {
5137+ uint64_t arg = heap.data[0].elem0;
5138+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5139+ }
5140+ {
5141+ uint64_t arg = 0;
5142+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5143+ }
5144+ // ACCUMULATE ARGUMENTS - BEGIN
5145+ {
5146+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5147+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5148+ }
5149+ {
5150+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5151+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5152+ }
5153+ // ACCUMULATE ARGUMENTS - END
5154+ uint64_t return_to = 18446744073709551433LLU;
5155+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5156+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5157+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5158+ heap.data[0].elem1 = heap.data[0].elem0;
5159+ heap.data[0].elem0 = restore;
5160+ state.addr = 367395560426147840LLU; // TYPECOPY__
5161+ break;
5162+ }
5163+ case 18446744073709551433LLU: // 999999997I'''''''''''''''
5164+ {
5165+ {
5166+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5167+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5168+
5169+ {
5170+ uint64_t arg = exchange;
5171+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5172+ }
5173+ }
5174+ {
5175+ uint64_t arg = heap.data[0].elem0;
5176+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5177+ }
5178+ {
5179+ uint64_t arg = 0;
5180+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5181+ }
5182+ // ACCUMULATE ARGUMENTS - BEGIN
5183+ {
5184+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5185+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5186+ }
5187+ {
5188+ uint64_t arg = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU));
5189+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5190+ }
5191+ // ACCUMULATE ARGUMENTS - END
5192+ uint64_t return_to = 18446744073709551432LLU;
5193+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5194+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5195+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5196+ heap.data[0].elem1 = heap.data[0].elem0;
5197+ heap.data[0].elem0 = restore;
5198+ state.addr = 552446646280519680LLU; // copyu64___
5199+ break;
5200+ }
5201+ case 18446744073709551432LLU: // 999999997H'''''''''''''''
5202+ {
5203+ {
5204+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5205+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5206+
5207+ {
5208+ uint64_t arg = exchange;
5209+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5210+ }
5211+ }
5212+ {
5213+ uint64_t arg = heap.data[0].elem0;
5214+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5215+ }
5216+ {
5217+ uint64_t arg = 0;
5218+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5219+ }
5220+ // ACCUMULATE ARGUMENTS - BEGIN
5221+ {
5222+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5223+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5224+ }
5225+ {
5226+ uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
5227+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5228+ }
5229+ // ACCUMULATE ARGUMENTS - END
5230+ uint64_t return_to = 18446744073709551431LLU;
5231+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5232+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5233+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5234+ heap.data[0].elem1 = heap.data[0].elem0;
5235+ heap.data[0].elem0 = restore;
5236+ state.addr = 58555672873677120LLU; // CPBALANCE_
5237+ break;
5238+ }
5239+ case 18446744073709551431LLU: // 999999997G'''''''''''''''
5240+ {
5241+ {
5242+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5243+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5244+
5245+ {
5246+ uint64_t arg = exchange;
5247+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5248+ }
5249+ }
5250+ {
5251+ uint64_t arg = heap.data[0].elem0;
5252+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5253+ }
5254+ {
5255+ uint64_t arg = 0;
5256+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5257+ }
5258+ // ACCUMULATE ARGUMENTS - BEGIN
5259+ {
5260+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5261+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5262+ }
5263+ {
5264+ uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU));
5265+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5266+ }
5267+ // ACCUMULATE ARGUMENTS - END
5268+ uint64_t return_to = 18446744073709551430LLU;
5269+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5270+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5271+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5272+ heap.data[0].elem1 = heap.data[0].elem0;
5273+ heap.data[0].elem0 = restore;
5274+ state.addr = 552446646280519680LLU; // copyu64___
5275+ break;
5276+ }
5277+ case 18446744073709551430LLU: // 999999997F'''''''''''''''
5278+ {
5279+ {
5280+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5281+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5282+
5283+ {
5284+ uint64_t arg = exchange;
5285+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5286+ }
5287+ }
5288+ // ACCUMULATE ARGUMENTS - END
5289+ uint64_t return_to = 18446744073709551434LLU;
5290+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5291+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5292+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5293+ heap.data[0].elem1 = heap.data[0].elem0;
5294+ heap.data[0].elem0 = restore;
5295+ state.addr = 782700512565788672LLU; // pardef____
5296+ break;
5297+ }
5298+ case 18446744073709551434LLU: // 999999997J'''''''''''''''
5299+ {
5300+ // parameter-reference u64 reference1 goes out of scope
5301+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 6
5302+ // parameter-reference continuity balance1__ goes out of scope
5303+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 5
5304+ // parameter-reference u64 mutable1__ goes out of scope
5305+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 4
5306+ // parameter-reference type______ type1_____ goes out of scope
5307+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 3
5308+ // parameter-reference pardef____ __________ goes out of scope
5309+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
5310+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5311+ {
5312+ uint64_t baseinfo = heap.data[0].elem1;
5313+ struct pair pair = unpair(&heap, &baseinfo);
5314+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5315+ state.addr = pair.elem1;
5316+ }
5317+ break;
5318+ }
5319+ case 782700512577972928LLU: // pardefscp_
5320+ {
5321+ {
5322+ uint64_t arg = 0;
5323+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5324+ }
5325+ {
5326+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
5327+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5328+ }
5329+ {
5330+ uint64_t arg = 0;
5331+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5332+ }
5333+ state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5334+ break;
5335+ }
5336+ case 18446744073709551429LLU: // 999999997E'''''''''''''''
5337+ {
5338+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5339+ {
5340+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5341+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5342+ {
5343+ state.addr = 18446744073709551428LLU; // 999999997D'''''''''''''''
5344+ break;
5345+ }
5346+ }
5347+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5348+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5349+ {
5350+ uint64_t arg = 0;
5351+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5352+ }
5353+ // ACCUMULATE ARGUMENTS - BEGIN
5354+ {
5355+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5356+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5357+ }
5358+ {
5359+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
5360+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5361+ }
5362+ // ACCUMULATE ARGUMENTS - END
5363+ uint64_t return_to = 18446744073709551424LLU;
5364+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5365+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5366+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5367+ heap.data[0].elem1 = heap.data[0].elem0;
5368+ heap.data[0].elem0 = restore;
5369+ state.addr = 296309897384864500LLU; // ParDefCopy
5370+ break;
5371+ }
5372+ case 18446744073709551424LLU: // 999999997_'''''''''''''''
5373+ {
5374+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551427LLU : 18446744073709551426LLU;
5375+ break;
5376+ }
5377+ case 18446744073709551427LLU: // 999999997C'''''''''''''''
5378+ {
5379+ {
5380+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size");
5381+ exit(-1);
5382+ }
5383+ // emitted destructur for type pardef____
5384+ // ACCUMULATE ARGUMENTS - BEGIN
5385+ {
5386+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5387+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5388+ }
5389+ // ACCUMULATE ARGUMENTS - END
5390+ uint64_t return_to = 18446744073709551423LLU;
5391+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5392+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5393+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5394+ heap.data[0].elem1 = heap.data[0].elem0;
5395+ heap.data[0].elem0 = restore;
5396+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
5397+ break;
5398+ }
5399+ case 18446744073709551423LLU: // 9999999969'''''''''''''''
5400+ {
5401+ // parameter pardef____ dst_______ goes out of scope
5402+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
5403+ break;
5404+ }
5405+ case 18446744073709551426LLU: // 999999997B'''''''''''''''
5406+ {
5407+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
5408+ break;
5409+ }
5410+ case 18446744073709551425LLU: // 999999997A'''''''''''''''
5411+ {
5412+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
5413+ // parameter-reference pardef____ src_______ goes out of scope
5414+ // parameter-reference list<pardef____> srcs______ goes out of scope
5415+ state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5416+ break;
5417+ }
5418+ case 18446744073709551428LLU: // 999999997D'''''''''''''''
5419+ {
5420+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
5421+ // variable list<pardef____> dsts______ goes out of scope
5422+ // (uninitialized -> no destructor-call)
5423+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
5424+ // parameter-reference list<pardef____> srcs______ goes out of scope
5425+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5426+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5427+ {
5428+ uint64_t baseinfo = heap.data[0].elem1;
5429+ struct pair pair = unpair(&heap, &baseinfo);
5430+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5431+ state.addr = pair.elem1;
5432+ }
5433+ break;
5434+ }
5435+ case 587581813005601646LLU: // elems2pars
5436+ {
5437+ {
5438+ uint64_t arg = 0;
5439+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5440+ }
5441+ {
5442+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
5443+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5444+ }
5445+ {
5446+ uint64_t arg = 0;
5447+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5448+ }
5449+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
5450+ break;
5451+ }
5452+ case 18446744073709551422LLU: // 9999999968'''''''''''''''
5453+ {
5454+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
5455+ {
5456+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
5457+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5458+ {
5459+ state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
5460+ break;
5461+ }
5462+ }
5463+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
5464+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
5465+ {
5466+ uint64_t arg = 0;
5467+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5468+ }
5469+ *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = 1;
5470+ {
5471+ uint64_t arg = 0;
5472+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5473+ }
5474+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*reference_*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5475+ {
5476+ uint64_t arg = 0;
5477+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5478+ }
5479+ // ACCUMULATE ARGUMENTS - BEGIN
5480+ {
5481+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
5482+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5483+ }
5484+ {
5485+ uint64_t arg = /*src_______*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 1LLU);
5486+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5487+ }
5488+ // ACCUMULATE ARGUMENTS - END
5489+ uint64_t return_to = 18446744073709551420LLU;
5490+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5491+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5492+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5493+ heap.data[0].elem1 = heap.data[0].elem0;
5494+ heap.data[0].elem0 = restore;
5495+ state.addr = 367395560426147840LLU; // TYPECOPY__
5496+ break;
5497+ }
5498+ case 18446744073709551420LLU: // 9999999966'''''''''''''''
5499+ {
5500+ {
5501+ uint64_t arg = 0;
5502+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5503+ }
5504+ // ACCUMULATE ARGUMENTS - BEGIN
5505+ {
5506+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
5507+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5508+ }
5509+ // ACCUMULATE ARGUMENTS - END
5510+ uint64_t return_to = 18446744073709551419LLU;
5511+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5512+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5513+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5514+ heap.data[0].elem1 = heap.data[0].elem0;
5515+ heap.data[0].elem0 = restore;
5516+ state.addr = 552437437528276992LLU; // consume___
5517+ break;
5518+ }
5519+ case 18446744073709551419LLU: // 9999999965'''''''''''''''
5520+ {
5521+ {
5522+ uint64_t arg = 0;
5523+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5524+ }
5525+ // ACCUMULATE ARGUMENTS - BEGIN
5526+ {
5527+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5528+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5529+ }
5530+ {
5531+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 11LLU, 8LLU);
5532+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5533+ }
5534+ {
5535+ uint64_t arg = /*mutable___*/*LOCAL_ACCESS(heap.data, 11LLU, 6LLU);
5536+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5537+ }
5538+ {
5539+ uint64_t arg = /*continuity*/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
5540+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5541+ }
5542+ {
5543+ uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 11LLU, 7LLU);
5544+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5545+ }
5546+ // ACCUMULATE ARGUMENTS - END
5547+ uint64_t return_to = 18446744073709551415LLU;
5548+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5549+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5550+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5551+ heap.data[0].elem1 = heap.data[0].elem0;
5552+ heap.data[0].elem0 = restore;
5553+ state.addr = 782700512565788672LLU; // pardef____
5554+ break;
5555+ }
5556+ case 18446744073709551415LLU: // 9999999961'''''''''''''''
5557+ {
5558+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &*LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551418LLU : 18446744073709551417LLU;
5559+ break;
5560+ }
5561+ case 18446744073709551418LLU: // 9999999964'''''''''''''''
5562+ {
5563+ fprintf(stderr, "%s", "pushing par ");
5564+ // ACCUMULATE ARGUMENTS - BEGIN
5565+ {
5566+ uint64_t arg = /*newpar____*/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU), 0LLU);
5567+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5568+ }
5569+ // ACCUMULATE ARGUMENTS - END
5570+ uint64_t return_to = 18446744073709551414LLU;
5571+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5572+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5573+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5574+ heap.data[0].elem1 = heap.data[0].elem0;
5575+ heap.data[0].elem0 = restore;
5576+ state.addr = 819847183518878432LLU; // reporttype
5577+ break;
5578+ }
5579+ case 18446744073709551414LLU: // 9999999960'''''''''''''''
5580+ {
5581+ fprintf(stderr, "%s", "\n");
5582+ {
5583+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elems2pars - recompile compiler with increased heap-size");
5584+ exit(-1);
5585+ }
5586+ // emitted destructur for type pardef____
5587+ // ACCUMULATE ARGUMENTS - BEGIN
5588+ {
5589+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5590+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5591+ }
5592+ // ACCUMULATE ARGUMENTS - END
5593+ uint64_t return_to = 18446744073709551413LLU;
5594+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5595+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5596+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5597+ heap.data[0].elem1 = heap.data[0].elem0;
5598+ heap.data[0].elem0 = restore;
5599+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
5600+ break;
5601+ }
5602+ case 18446744073709551413LLU: // 999999996z'''''''''''''''
5603+ {
5604+ // parameter pardef____ newpar____ goes out of scope
5605+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
5606+ break;
5607+ }
5608+ case 18446744073709551417LLU: // 9999999963'''''''''''''''
5609+ {
5610+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
5611+ break;
5612+ }
5613+ case 18446744073709551416LLU: // 9999999962'''''''''''''''
5614+ {
5615+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
5616+ // variable continuity continuity goes out of scope
5617+ // (uninitialized -> no destructor-call)
5618+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 10
5619+ // variable type______ type______ goes out of scope
5620+ // (uninitialized -> no destructor-call)
5621+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 9
5622+ // variable u64 reference_ goes out of scope
5623+ // (uninitialized -> no destructor-call)
5624+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 8
5625+ // variable u64 mutable___ goes out of scope
5626+ // (uninitialized -> no destructor-call)
5627+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 7
5628+ // parameter-reference elemdef___ src_______ goes out of scope
5629+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5630+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
5631+ break;
5632+ }
5633+ case 18446744073709551421LLU: // 9999999967'''''''''''''''
5634+ {
5635+ swap(&*LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
5636+ // variable list<pardef____> dsts______ goes out of scope
5637+ // (uninitialized -> no destructor-call)
5638+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 4
5639+ // parameter u64 reference_ goes out of scope
5640+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 3
5641+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5642+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5643+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5644+ {
5645+ uint64_t baseinfo = heap.data[0].elem1;
5646+ struct pair pair = unpair(&heap, &baseinfo);
5647+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5648+ state.addr = pair.elem1;
5649+ }
5650+ break;
5651+ }
5652+ case 101193007747052544LLU: // ElemDefCP_
5653+ {
5654+ {
5655+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5656+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5657+ }
5658+ {
5659+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5660+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5661+ }
5662+ // ACCUMULATE ARGUMENTS - BEGIN
5663+ {
5664+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
5665+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5666+ }
5667+ {
5668+ uint64_t arg = heap.data[0].elem0;
5669+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5670+ }
5671+ {
5672+ uint64_t arg = 0;
5673+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5674+ }
5675+ // ACCUMULATE ARGUMENTS - BEGIN
5676+ {
5677+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5678+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5679+ }
5680+ {
5681+ uint64_t arg = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
5682+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5683+ }
5684+ // ACCUMULATE ARGUMENTS - END
5685+ uint64_t return_to = 18446744073709551410LLU;
5686+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5687+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5688+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5689+ heap.data[0].elem1 = heap.data[0].elem0;
5690+ heap.data[0].elem0 = restore;
5691+ state.addr = 552446646280519680LLU; // copyu64___
5692+ break;
5693+ }
5694+ case 18446744073709551410LLU: // 999999996w'''''''''''''''
5695+ {
5696+ {
5697+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
5698+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
5699+
5700+ {
5701+ uint64_t arg = exchange;
5702+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5703+ }
5704+ }
5705+ {
5706+ uint64_t arg = heap.data[0].elem0;
5707+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5708+ }
5709+ {
5710+ uint64_t arg = 0;
5711+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5712+ }
5713+ // ACCUMULATE ARGUMENTS - BEGIN
5714+ {
5715+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5716+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5717+ }
5718+ {
5719+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU);
5720+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5721+ }
5722+ // ACCUMULATE ARGUMENTS - END
5723+ uint64_t return_to = 18446744073709551409LLU;
5724+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5725+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5726+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5727+ heap.data[0].elem1 = heap.data[0].elem0;
5728+ heap.data[0].elem0 = restore;
5729+ state.addr = 367395560426147840LLU; // TYPECOPY__
5730+ break;
5731+ }
5732+ case 18446744073709551409LLU: // 999999996v'''''''''''''''
5733+ {
5734+ {
5735+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
5736+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
5737+
5738+ {
5739+ uint64_t arg = exchange;
5740+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5741+ }
5742+ }
5743+ // ACCUMULATE ARGUMENTS - END
5744+ uint64_t return_to = 18446744073709551411LLU;
5745+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5746+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5747+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5748+ heap.data[0].elem1 = heap.data[0].elem0;
5749+ heap.data[0].elem0 = restore;
5750+ state.addr = 587581796494082048LLU; // elemdef___
5751+ break;
5752+ }
5753+ case 18446744073709551411LLU: // 999999996x'''''''''''''''
5754+ {
5755+ // parameter-reference type______ type1_____ goes out of scope
5756+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 4
5757+ // parameter-reference u64 id1_______ goes out of scope
5758+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 3
5759+ // parameter-reference elemdef___ __________ goes out of scope
5760+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
5761+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5762+ {
5763+ uint64_t baseinfo = heap.data[0].elem1;
5764+ struct pair pair = unpair(&heap, &baseinfo);
5765+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5766+ state.addr = pair.elem1;
5767+ }
5768+ break;
5769+ }
5770+ case 587581796494272427LLU: // elemdefscp
5771+ {
5772+ {
5773+ uint64_t arg = 0;
5774+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5775+ }
5776+ {
5777+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
5778+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5779+ }
5780+ {
5781+ uint64_t arg = 0;
5782+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5783+ }
5784+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
5785+ break;
5786+ }
5787+ case 18446744073709551408LLU: // 999999996u'''''''''''''''
5788+ {
5789+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5790+ {
5791+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5792+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5793+ {
5794+ state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
5795+ break;
5796+ }
5797+ }
5798+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5799+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5800+ {
5801+ uint64_t arg = 0;
5802+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5803+ }
5804+ // ACCUMULATE ARGUMENTS - BEGIN
5805+ {
5806+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5807+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5808+ }
5809+ {
5810+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
5811+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5812+ }
5813+ // ACCUMULATE ARGUMENTS - END
5814+ uint64_t return_to = 18446744073709551403LLU;
5815+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5816+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5817+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5818+ heap.data[0].elem1 = heap.data[0].elem0;
5819+ heap.data[0].elem0 = restore;
5820+ state.addr = 101193007747052544LLU; // ElemDefCP_
5821+ break;
5822+ }
5823+ case 18446744073709551403LLU: // 999999996p'''''''''''''''
5824+ {
5825+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551406LLU : 18446744073709551405LLU;
5826+ break;
5827+ }
5828+ case 18446744073709551406LLU: // 999999996s'''''''''''''''
5829+ {
5830+ fprintf(stderr, "%s", "pushing par ");
5831+ // ACCUMULATE ARGUMENTS - BEGIN
5832+ {
5833+ uint64_t arg = /*dst_______*/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU), 1LLU);
5834+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5835+ }
5836+ // ACCUMULATE ARGUMENTS - END
5837+ uint64_t return_to = 18446744073709551402LLU;
5838+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5839+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5840+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5841+ heap.data[0].elem1 = heap.data[0].elem0;
5842+ heap.data[0].elem0 = restore;
5843+ state.addr = 819847183518878432LLU; // reporttype
5844+ break;
5845+ }
5846+ case 18446744073709551402LLU: // 999999996o'''''''''''''''
5847+ {
5848+ fprintf(stderr, "%s", "\n");
5849+ {
5850+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elemdesfcp - recompile compiler with increased heap-size");
5851+ exit(-1);
5852+ }
5853+ // emitted destructur for type elemdef___
5854+ // ACCUMULATE ARGUMENTS - BEGIN
5855+ {
5856+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5857+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5858+ }
5859+ // ACCUMULATE ARGUMENTS - END
5860+ uint64_t return_to = 18446744073709551401LLU;
5861+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5862+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5863+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5864+ heap.data[0].elem1 = heap.data[0].elem0;
5865+ heap.data[0].elem0 = restore;
5866+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
5867+ break;
5868+ }
5869+ case 18446744073709551401LLU: // 999999996n'''''''''''''''
5870+ {
5871+ // parameter elemdef___ dst_______ goes out of scope
5872+ state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
5873+ break;
5874+ }
5875+ case 18446744073709551405LLU: // 999999996r'''''''''''''''
5876+ {
5877+ state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
5878+ break;
5879+ }
5880+ case 18446744073709551404LLU: // 999999996q'''''''''''''''
5881+ {
5882+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
5883+ // parameter-reference elemdef___ src_______ goes out of scope
5884+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5885+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
5886+ break;
5887+ }
5888+ case 18446744073709551407LLU: // 999999996t'''''''''''''''
5889+ {
5890+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
5891+ // variable list<elemdef___> dsts______ goes out of scope
5892+ // (uninitialized -> no destructor-call)
5893+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
5894+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5895+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5896+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5897+ {
5898+ uint64_t baseinfo = heap.data[0].elem1;
5899+ struct pair pair = unpair(&heap, &baseinfo);
5900+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5901+ state.addr = pair.elem1;
5902+ }
5903+ break;
5904+ }
5905+ case 325750391286068249LLU: // RESDEFCOPY
5906+ {
5907+ {
5908+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5909+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5910+ }
5911+ {
5912+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5913+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5914+ }
5915+ {
5916+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
5917+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5918+ }
5919+ // ACCUMULATE ARGUMENTS - BEGIN
5920+ {
5921+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
5922+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5923+ }
5924+ {
5925+ uint64_t arg = heap.data[0].elem0;
5926+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5927+ }
5928+ {
5929+ uint64_t arg = 0;
5930+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5931+ }
5932+ // ACCUMULATE ARGUMENTS - BEGIN
5933+ {
5934+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
5935+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5936+ }
5937+ {
5938+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
5939+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5940+ }
5941+ // ACCUMULATE ARGUMENTS - END
5942+ uint64_t return_to = 18446744073709551398LLU;
5943+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5944+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5945+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5946+ heap.data[0].elem1 = heap.data[0].elem0;
5947+ heap.data[0].elem0 = restore;
5948+ state.addr = 367395560426147840LLU; // TYPECOPY__
5949+ break;
5950+ }
5951+ case 18446744073709551398LLU: // 999999996k'''''''''''''''
5952+ {
5953+ {
5954+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5955+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
5956+
5957+ {
5958+ uint64_t arg = exchange;
5959+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5960+ }
5961+ }
5962+ {
5963+ uint64_t arg = heap.data[0].elem0;
5964+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5965+ }
5966+ {
5967+ uint64_t arg = 0;
5968+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5969+ }
5970+ // ACCUMULATE ARGUMENTS - BEGIN
5971+ {
5972+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
5973+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5974+ }
5975+ {
5976+ uint64_t arg = /*idx1______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
5977+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5978+ }
5979+ // ACCUMULATE ARGUMENTS - END
5980+ uint64_t return_to = 18446744073709551397LLU;
5981+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5982+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5983+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5984+ heap.data[0].elem1 = heap.data[0].elem0;
5985+ heap.data[0].elem0 = restore;
5986+ state.addr = 552446646280519680LLU; // copyu64___
5987+ break;
5988+ }
5989+ case 18446744073709551397LLU: // 999999996j'''''''''''''''
5990+ {
5991+ {
5992+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5993+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
5994+
5995+ {
5996+ uint64_t arg = exchange;
5997+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5998+ }
5999+ }
6000+ {
6001+ uint64_t arg = heap.data[0].elem0;
6002+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6003+ }
6004+ {
6005+ uint64_t arg = 0;
6006+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6007+ }
6008+ // ACCUMULATE ARGUMENTS - BEGIN
6009+ {
6010+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6011+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6012+ }
6013+ {
6014+ uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
6015+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6016+ }
6017+ // ACCUMULATE ARGUMENTS - END
6018+ uint64_t return_to = 18446744073709551396LLU;
6019+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6020+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6021+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6022+ heap.data[0].elem1 = heap.data[0].elem0;
6023+ heap.data[0].elem0 = restore;
6024+ state.addr = 552446646280519680LLU; // copyu64___
6025+ break;
6026+ }
6027+ case 18446744073709551396LLU: // 999999996i'''''''''''''''
6028+ {
6029+ {
6030+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6031+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6032+
6033+ {
6034+ uint64_t arg = exchange;
6035+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6036+ }
6037+ }
6038+ // ACCUMULATE ARGUMENTS - END
6039+ uint64_t return_to = 18446744073709551399LLU;
6040+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6041+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6042+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6043+ heap.data[0].elem1 = heap.data[0].elem0;
6044+ heap.data[0].elem0 = restore;
6045+ state.addr = 819859607768530944LLU; // resdest___
6046+ break;
6047+ }
6048+ case 18446744073709551399LLU: // 999999996l'''''''''''''''
6049+ {
6050+ // parameter-reference u64 reference1 goes out of scope
6051+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 5
6052+ // parameter-reference u64 idx1______ goes out of scope
6053+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx1______ at 4
6054+ // parameter-reference type______ type1_____ goes out of scope
6055+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 3
6056+ // parameter-reference resdest___ __________ goes out of scope
6057+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6058+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6059+ {
6060+ uint64_t baseinfo = heap.data[0].elem1;
6061+ struct pair pair = unpair(&heap, &baseinfo);
6062+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6063+ state.addr = pair.elem1;
6064+ }
6065+ break;
6066+ }
6067+ case 18446744073709551395LLU: // 999999996h'''''''''''''''
6068+ {
6069+ {
6070+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6071+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6072+ }
6073+ // emitted destructur for type u64
6074+ // RELEASE temporary destructor-variable
6075+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6076+ {
6077+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6078+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6079+ }
6080+ // emitted destructur for type u64
6081+ // RELEASE temporary destructor-variable
6082+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6083+ // RELEASE destructor-argument
6084+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
6085+ {
6086+ uint64_t baseinfo = heap.data[0].elem1;
6087+ struct pair pair = unpair(&heap, &baseinfo);
6088+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6089+ state.addr = pair.elem1;
6090+ }
6091+ break;
6092+ }
6093+ case 746649810298337261LLU: // nametoaddr
6094+ {
6095+ // struct-constructor nametoaddr
6096+ {
6097+ uint64_t result_tuple = 0;
6098+ // copy references
6099+ {
6100+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 0LLU + 1);
6101+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
6102+ }
6103+ {
6104+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 1LLU + 1);
6105+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
6106+ }
6107+ // release parameters
6108+ {
6109+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6110+ }
6111+ {
6112+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6113+ }
6114+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
6115+ }
6116+ {
6117+ uint64_t baseinfo = heap.data[0].elem1;
6118+ struct pair pair = unpair(&heap, &baseinfo);
6119+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6120+ state.addr = pair.elem1;
6121+ }
6122+ break;
6123+ }
6124+ case 18446744073709551394LLU: // 999999996g'''''''''''''''
6125+ {
6126+ {
6127+ uint64_t arg = tree_pop_move(&heap, 7LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6128+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6129+ }
6130+ // emitted destructur for type u64
6131+ // RELEASE temporary destructor-variable
6132+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6133+ {
6134+ uint64_t arg = tree_pop_move(&heap, 6LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6135+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6136+ }
6137+ // emitted destructur for type u64
6138+ // RELEASE temporary destructor-variable
6139+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6140+ {
6141+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6142+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6143+ }
6144+ // emitted destructur for type u64
6145+ // RELEASE temporary destructor-variable
6146+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6147+ {
6148+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6149+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6150+ }
6151+ // emitted destructur for type u64
6152+ // RELEASE temporary destructor-variable
6153+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6154+ {
6155+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6156+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6157+ }
6158+ // emitted destructur for type u64
6159+ // RELEASE temporary destructor-variable
6160+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6161+ {
6162+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6163+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6164+ }
6165+ // emitted destructur for type list<pardef____>
6166+ state.addr = 18446744073709551392LLU; // 999999996e'''''''''''''''
6167+ break;
6168+ }
6169+ case 18446744073709551392LLU: // 999999996e'''''''''''''''
6170+ {
6171+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/)
6172+ {
6173+ state.addr = 18446744073709551393LLU; // 999999996f'''''''''''''''
6174+ break;
6175+ }
6176+ // temporary list-element
6177+ {
6178+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/, 11);
6179+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6180+ }
6181+ // ACCUMULATE ARGUMENTS - BEGIN
6182+ {
6183+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
6184+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6185+ }
6186+ // ACCUMULATE ARGUMENTS - END
6187+ uint64_t return_to = 18446744073709551391LLU;
6188+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6189+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6190+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6191+ heap.data[0].elem1 = heap.data[0].elem0;
6192+ heap.data[0].elem0 = restore;
6193+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
6194+ break;
6195+ }
6196+ case 18446744073709551391LLU: // 999999996d'''''''''''''''
6197+ {
6198+ // RELEASE temporary destructor-variable
6199+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6200+ state.addr = 18446744073709551392LLU; // 999999996e'''''''''''''''
6201+ break;
6202+ }
6203+ case 18446744073709551393LLU: // 999999996f'''''''''''''''
6204+ {
6205+ // RELEASE temporary destructor-variable
6206+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6207+ {
6208+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6209+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6210+ }
6211+ // emitted destructur for type list<resdest___>
6212+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
6213+ break;
6214+ }
6215+ case 18446744073709551389LLU: // 999999996b'''''''''''''''
6216+ {
6217+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/)
6218+ {
6219+ state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
6220+ break;
6221+ }
6222+ // temporary list-element
6223+ {
6224+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/, 8);
6225+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6226+ }
6227+ // ACCUMULATE ARGUMENTS - BEGIN
6228+ {
6229+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
6230+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6231+ }
6232+ // ACCUMULATE ARGUMENTS - END
6233+ uint64_t return_to = 18446744073709551388LLU;
6234+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6235+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6236+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6237+ heap.data[0].elem1 = heap.data[0].elem0;
6238+ heap.data[0].elem0 = restore;
6239+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6240+ break;
6241+ }
6242+ case 18446744073709551388LLU: // 999999996a'''''''''''''''
6243+ {
6244+ // RELEASE temporary destructor-variable
6245+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6246+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
6247+ break;
6248+ }
6249+ case 18446744073709551390LLU: // 999999996c'''''''''''''''
6250+ {
6251+ // RELEASE temporary destructor-variable
6252+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6253+ // RELEASE destructor-argument
6254+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
6255+ {
6256+ uint64_t baseinfo = heap.data[0].elem1;
6257+ struct pair pair = unpair(&heap, &baseinfo);
6258+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6259+ state.addr = pair.elem1;
6260+ }
6261+ break;
6262+ }
6263+ case 608168382267297792LLU: // function__
6264+ {
6265+ // struct-constructor function__
6266+ {
6267+ uint64_t result_tuple = 0;
6268+ // copy references
6269+ {
6270+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 0LLU + 1);
6271+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
6272+ }
6273+ {
6274+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 1LLU + 1);
6275+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
6276+ }
6277+ {
6278+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 2LLU + 1);
6279+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
6280+ }
6281+ {
6282+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 3LLU + 1);
6283+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
6284+ }
6285+ {
6286+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 4LLU + 1);
6287+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
6288+ }
6289+ {
6290+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 5LLU + 1);
6291+ tree_push_move(&heap, 5LLU, &result_tuple, &elem);
6292+ }
6293+ {
6294+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 6LLU + 1);
6295+ tree_push_move(&heap, 6LLU, &result_tuple, &elem);
6296+ }
6297+ // release parameters
6298+ {
6299+ (void)LOCAL_POP_MOVE(&heap, 7LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6300+ }
6301+ {
6302+ (void)LOCAL_POP_MOVE(&heap, 6LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6303+ }
6304+ {
6305+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6306+ }
6307+ {
6308+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6309+ }
6310+ {
6311+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6312+ }
6313+ {
6314+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6315+ }
6316+ {
6317+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6318+ }
6319+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
6320+ }
6321+ {
6322+ uint64_t baseinfo = heap.data[0].elem1;
6323+ struct pair pair = unpair(&heap, &baseinfo);
6324+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6325+ state.addr = pair.elem1;
6326+ }
6327+ break;
6328+ }
6329+ case 121779622511284459LLU: // FunctionCp
6330+ {
6331+ {
6332+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
6333+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6334+ }
6335+ {
6336+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
6337+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6338+ }
6339+ {
6340+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
6341+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6342+ }
6343+ {
6344+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU);
6345+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6346+ }
6347+ {
6348+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 4LLU);
6349+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6350+ }
6351+ {
6352+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 5LLU);
6353+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6354+ }
6355+ {
6356+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 6LLU);
6357+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6358+ }
6359+ {
6360+ uint64_t arg = 0;
6361+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6362+ }
6363+ {
6364+ uint64_t arg = /*resultpars*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 2LLU));
6365+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6366+ }
6367+ {
6368+ uint64_t arg = 0;
6369+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6370+ }
6371+ state.addr = 18446744073709551386LLU; // 999999996Z'''''''''''''''
6372+ break;
6373+ }
6374+ case 18446744073709551386LLU: // 999999996Z'''''''''''''''
6375+ {
6376+ if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
6377+ {
6378+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12
6379+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
6380+ {
6381+ state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
6382+ break;
6383+ }
6384+ }
6385+ /*direct*/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = (*LOCAL_ACCESS(heap.data, 12LLU, 10LLU) << 1) + 1LLU;
6386+ *LOCAL_ACCESS(heap.data, 12LLU, 10LLU) = heap.data[*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)].elem0;
6387+ {
6388+ uint64_t arg = 0;
6389+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6390+ }
6391+ // ACCUMULATE ARGUMENTS - BEGIN
6392+ {
6393+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6394+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6395+ }
6396+ {
6397+ uint64_t arg = /*rp________*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU);
6398+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6399+ }
6400+ // ACCUMULATE ARGUMENTS - END
6401+ uint64_t return_to = 18446744073709551381LLU;
6402+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6403+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6404+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6405+ heap.data[0].elem1 = heap.data[0].elem0;
6406+ heap.data[0].elem0 = restore;
6407+ state.addr = 333468934555566080LLU; // ResCopy___
6408+ break;
6409+ }
6410+ case 18446744073709551381LLU: // 999999996U'''''''''''''''
6411+ {
6412+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551384LLU : 18446744073709551383LLU;
6413+ break;
6414+ }
6415+ case 18446744073709551384LLU: // 999999996X'''''''''''''''
6416+ {
6417+ {
6418+ fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");
6419+ exit(-1);
6420+ }
6421+ // emitted destructur for type resdest___
6422+ // ACCUMULATE ARGUMENTS - BEGIN
6423+ {
6424+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6425+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6426+ }
6427+ // ACCUMULATE ARGUMENTS - END
6428+ uint64_t return_to = 18446744073709551380LLU;
6429+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6430+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6431+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6432+ heap.data[0].elem1 = heap.data[0].elem0;
6433+ heap.data[0].elem0 = restore;
6434+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6435+ break;
6436+ }
6437+ case 18446744073709551380LLU: // 999999996T'''''''''''''''
6438+ {
6439+ // parameter resdest___ RP________ goes out of scope
6440+ state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
6441+ break;
6442+ }
6443+ case 18446744073709551383LLU: // 999999996W'''''''''''''''
6444+ {
6445+ state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
6446+ break;
6447+ }
6448+ case 18446744073709551382LLU: // 999999996V'''''''''''''''
6449+ {
6450+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
6451+ // parameter-reference resdest___ rp________ goes out of scope
6452+ // parameter-reference list<resdest___> resultpars goes out of scope
6453+ state.addr = 18446744073709551386LLU; // 999999996Z'''''''''''''''
6454+ break;
6455+ }
6456+ case 18446744073709551385LLU: // 999999996Y'''''''''''''''
6457+ {
6458+ list_reverse(heap.data, &/*RESULTPARS*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
6459+ {
6460+ uint64_t arg = 0;
6461+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6462+ }
6463+ {
6464+ uint64_t arg = /*defpars___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 11LLU, 3LLU));
6465+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6466+ }
6467+ {
6468+ uint64_t arg = 0;
6469+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6470+ }
6471+ state.addr = 18446744073709551379LLU; // 999999996S'''''''''''''''
6472+ break;
6473+ }
6474+ case 18446744073709551379LLU: // 999999996S'''''''''''''''
6475+ {
6476+ if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU))
6477+ {
6478+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
6479+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12
6480+ {
6481+ state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
6482+ break;
6483+ }
6484+ }
6485+ /*direct*/*LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = (*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) << 1) + 1LLU;
6486+ *LOCAL_ACCESS(heap.data, 13LLU, 11LLU) = heap.data[*LOCAL_ACCESS(heap.data, 13LLU, 11LLU)].elem0;
6487+ {
6488+ uint64_t arg = 0;
6489+ LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6490+ }
6491+ // ACCUMULATE ARGUMENTS - BEGIN
6492+ {
6493+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
6494+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6495+ }
6496+ {
6497+ uint64_t arg = /*dp________*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU);
6498+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6499+ }
6500+ // ACCUMULATE ARGUMENTS - END
6501+ uint64_t return_to = 18446744073709551374LLU;
6502+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6503+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6504+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6505+ heap.data[0].elem1 = heap.data[0].elem0;
6506+ heap.data[0].elem0 = restore;
6507+ state.addr = 296309897384864500LLU; // ParDefCopy
6508+ break;
6509+ }
6510+ case 18446744073709551374LLU: // 999999996N'''''''''''''''
6511+ {
6512+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551377LLU : 18446744073709551376LLU;
6513+ break;
6514+ }
6515+ case 18446744073709551377LLU: // 999999996Q'''''''''''''''
6516+ {
6517+ {
6518+ fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");
6519+ exit(-1);
6520+ }
6521+ // emitted destructur for type pardef____
6522+ // ACCUMULATE ARGUMENTS - BEGIN
6523+ {
6524+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
6525+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6526+ }
6527+ // ACCUMULATE ARGUMENTS - END
6528+ uint64_t return_to = 18446744073709551373LLU;
6529+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6530+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6531+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6532+ heap.data[0].elem1 = heap.data[0].elem0;
6533+ heap.data[0].elem0 = restore;
6534+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
6535+ break;
6536+ }
6537+ case 18446744073709551373LLU: // 999999996M'''''''''''''''
6538+ {
6539+ // parameter pardef____ DP________ goes out of scope
6540+ state.addr = 18446744073709551375LLU; // 999999996O'''''''''''''''
6541+ break;
6542+ }
6543+ case 18446744073709551376LLU: // 999999996P'''''''''''''''
6544+ {
6545+ state.addr = 18446744073709551375LLU; // 999999996O'''''''''''''''
6546+ break;
6547+ }
6548+ case 18446744073709551375LLU: // 999999996O'''''''''''''''
6549+ {
6550+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14
6551+ // parameter-reference pardef____ dp________ goes out of scope
6552+ // parameter-reference list<pardef____> defpars___ goes out of scope
6553+ state.addr = 18446744073709551379LLU; // 999999996S'''''''''''''''
6554+ break;
6555+ }
6556+ case 18446744073709551378LLU: // 999999996R'''''''''''''''
6557+ {
6558+ list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU));
6559+ // ACCUMULATE ARGUMENTS - BEGIN
6560+ {
6561+ uint64_t arg = *LOCAL_ACCESS(heap.data, 11LLU, 0LLU);
6562+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6563+ }
6564+ {
6565+ uint64_t arg = /*RESULTPARS*/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
6566+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6567+ }
6568+ {
6569+ uint64_t arg = /*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU);
6570+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6571+ }
6572+ {
6573+ uint64_t arg = heap.data[0].elem0;
6574+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6575+ }
6576+ {
6577+ uint64_t arg = 0;
6578+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6579+ }
6580+ // ACCUMULATE ARGUMENTS - BEGIN
6581+ {
6582+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6583+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6584+ }
6585+ {
6586+ uint64_t arg = /*sizeonheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 4LLU));
6587+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6588+ }
6589+ // ACCUMULATE ARGUMENTS - END
6590+ uint64_t return_to = 18446744073709551371LLU;
6591+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6592+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6593+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6594+ heap.data[0].elem1 = heap.data[0].elem0;
6595+ heap.data[0].elem0 = restore;
6596+ state.addr = 552446646280519680LLU; // copyu64___
6597+ break;
6598+ }
6599+ case 18446744073709551371LLU: // 999999996K'''''''''''''''
6600+ {
6601+ {
6602+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6603+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6604+
6605+ {
6606+ uint64_t arg = exchange;
6607+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6608+ }
6609+ }
6610+ {
6611+ uint64_t arg = heap.data[0].elem0;
6612+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6613+ }
6614+ {
6615+ uint64_t arg = 0;
6616+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6617+ }
6618+ // ACCUMULATE ARGUMENTS - BEGIN
6619+ {
6620+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6621+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6622+ }
6623+ {
6624+ uint64_t arg = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU));
6625+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6626+ }
6627+ // ACCUMULATE ARGUMENTS - END
6628+ uint64_t return_to = 18446744073709551370LLU;
6629+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6630+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6631+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6632+ heap.data[0].elem1 = heap.data[0].elem0;
6633+ heap.data[0].elem0 = restore;
6634+ state.addr = 552446646280519680LLU; // copyu64___
6635+ break;
6636+ }
6637+ case 18446744073709551370LLU: // 999999996J'''''''''''''''
6638+ {
6639+ {
6640+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6641+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6642+
6643+ {
6644+ uint64_t arg = exchange;
6645+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6646+ }
6647+ }
6648+ {
6649+ uint64_t arg = heap.data[0].elem0;
6650+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6651+ }
6652+ {
6653+ uint64_t arg = 0;
6654+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6655+ }
6656+ // ACCUMULATE ARGUMENTS - BEGIN
6657+ {
6658+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6659+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6660+ }
6661+ {
6662+ uint64_t arg = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU));
6663+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6664+ }
6665+ // ACCUMULATE ARGUMENTS - END
6666+ uint64_t return_to = 18446744073709551369LLU;
6667+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6668+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6669+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6670+ heap.data[0].elem1 = heap.data[0].elem0;
6671+ heap.data[0].elem0 = restore;
6672+ state.addr = 552446646280519680LLU; // copyu64___
6673+ break;
6674+ }
6675+ case 18446744073709551369LLU: // 999999996I'''''''''''''''
6676+ {
6677+ {
6678+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6679+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6680+
6681+ {
6682+ uint64_t arg = exchange;
6683+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6684+ }
6685+ }
6686+ {
6687+ uint64_t arg = heap.data[0].elem0;
6688+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6689+ }
6690+ {
6691+ uint64_t arg = 0;
6692+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6693+ }
6694+ // ACCUMULATE ARGUMENTS - BEGIN
6695+ {
6696+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6697+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6698+ }
6699+ {
6700+ uint64_t arg = /*finite____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU));
6701+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6702+ }
6703+ // ACCUMULATE ARGUMENTS - END
6704+ uint64_t return_to = 18446744073709551368LLU;
6705+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6706+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6707+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6708+ heap.data[0].elem1 = heap.data[0].elem0;
6709+ heap.data[0].elem0 = restore;
6710+ state.addr = 552446646280519680LLU; // copyu64___
6711+ break;
6712+ }
6713+ case 18446744073709551368LLU: // 999999996H'''''''''''''''
6714+ {
6715+ {
6716+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6717+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6718+
6719+ {
6720+ uint64_t arg = exchange;
6721+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6722+ }
6723+ }
6724+ {
6725+ uint64_t arg = heap.data[0].elem0;
6726+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6727+ }
6728+ {
6729+ uint64_t arg = 0;
6730+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6731+ }
6732+ // ACCUMULATE ARGUMENTS - BEGIN
6733+ {
6734+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6735+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6736+ }
6737+ {
6738+ uint64_t arg = /*safe______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 8LLU));
6739+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6740+ }
6741+ // ACCUMULATE ARGUMENTS - END
6742+ uint64_t return_to = 18446744073709551367LLU;
6743+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6744+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6745+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6746+ heap.data[0].elem1 = heap.data[0].elem0;
6747+ heap.data[0].elem0 = restore;
6748+ state.addr = 552446646280519680LLU; // copyu64___
6749+ break;
6750+ }
6751+ case 18446744073709551367LLU: // 999999996G'''''''''''''''
6752+ {
6753+ {
6754+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6755+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6756+
6757+ {
6758+ uint64_t arg = exchange;
6759+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6760+ }
6761+ }
6762+ // ACCUMULATE ARGUMENTS - END
6763+ uint64_t return_to = 18446744073709551372LLU;
6764+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0));
6765+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6766+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6767+ heap.data[0].elem1 = heap.data[0].elem0;
6768+ heap.data[0].elem0 = restore;
6769+ state.addr = 608168382267297792LLU; // function__
6770+ break;
6771+ }
6772+ case 18446744073709551372LLU: // 999999996L'''''''''''''''
6773+ {
6774+ // variable list<pardef____> DEFPARS___ goes out of scope
6775+ // (uninitialized -> no destructor-call)
6776+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference DEFPARS___ at 11
6777+ // variable list<resdest___> RESULTPARS goes out of scope
6778+ // (uninitialized -> no destructor-call)
6779+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference RESULTPARS at 10
6780+ // parameter-reference u64 safe______ goes out of scope
6781+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 9
6782+ // parameter-reference u64 finite____ goes out of scope
6783+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference finite____ at 8
6784+ // parameter-reference u64 complete__ goes out of scope
6785+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference complete__ at 7
6786+ // parameter-reference u64 defbodysz_ goes out of scope
6787+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defbodysz_ at 6
6788+ // parameter-reference u64 sizeonheap goes out of scope
6789+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeonheap at 5
6790+ // parameter-reference list<pardef____> defpars___ goes out of scope
6791+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defpars___ at 4
6792+ // parameter-reference list<resdest___> resultpars goes out of scope
6793+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultpars at 3
6794+ // parameter-reference function__ __________ goes out of scope
6795+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6796+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6797+ {
6798+ uint64_t baseinfo = heap.data[0].elem1;
6799+ struct pair pair = unpair(&heap, &baseinfo);
6800+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6801+ state.addr = pair.elem1;
6802+ }
6803+ break;
6804+ }
6805+ case 606150496152849376LLU: // fncomplete
6806+ {
6807+ {
6808+ uint64_t arg = 0;
6809+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6810+ }
6811+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU));
6812+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
6813+ // variable u64 result____ goes out of scope
6814+ // emitted destructur for type u64
6815+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
6816+ // parameter-reference function__ fn________ goes out of scope
6817+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
6818+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6819+ {
6820+ uint64_t baseinfo = heap.data[0].elem1;
6821+ struct pair pair = unpair(&heap, &baseinfo);
6822+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6823+ state.addr = pair.elem1;
6824+ }
6825+ break;
6826+ }
6827+ case 606163278933917696LLU: // fnfinite__
6828+ {
6829+ {
6830+ uint64_t arg = 0;
6831+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6832+ }
6833+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 5LLU));
6834+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
6835+ // variable u64 result____ goes out of scope
6836+ // emitted destructur for type u64
6837+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
6838+ // parameter-reference function__ fn________ goes out of scope
6839+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
6840+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6841+ {
6842+ uint64_t baseinfo = heap.data[0].elem1;
6843+ struct pair pair = unpair(&heap, &baseinfo);
6844+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6845+ state.addr = pair.elem1;
6846+ }
6847+ break;
6848+ }
6849+ case 606219895113252864LLU: // fnsafe____
6850+ {
6851+ {
6852+ uint64_t arg = 0;
6853+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6854+ }
6855+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 6LLU));
6856+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
6857+ // variable u64 result____ goes out of scope
6858+ // emitted destructur for type u64
6859+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
6860+ // parameter-reference function__ fn________ goes out of scope
6861+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
6862+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6863+ {
6864+ uint64_t baseinfo = heap.data[0].elem1;
6865+ struct pair pair = unpair(&heap, &baseinfo);
6866+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6867+ state.addr = pair.elem1;
6868+ }
6869+ break;
6870+ }
6871+ case 94950668770481299LLU: // EQURESPARS
6872+ {
6873+
6874+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1;
6875+ {
6876+ uint64_t arg = 0;
6877+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6878+ }
6879+ {
6880+ uint64_t arg = /*yresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
6881+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6882+ }
6883+ {
6884+ uint64_t arg = 0;
6885+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6886+ }
6887+ state.addr = 18446744073709551366LLU; // 999999996F'''''''''''''''
6888+ break;
6889+ }
6890+ case 18446744073709551366LLU: // 999999996F'''''''''''''''
6891+ {
6892+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
6893+ {
6894+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
6895+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
6896+ {
6897+ state.addr = 18446744073709551365LLU; // 999999996E'''''''''''''''
6898+ break;
6899+ }
6900+ }
6901+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
6902+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
6903+ {
6904+ uint64_t arg = 0;
6905+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6906+ }
6907+ // ACCUMULATE ARGUMENTS - BEGIN
6908+ {
6909+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
6910+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6911+ }
6912+ {
6913+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
6914+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6915+ }
6916+ // ACCUMULATE ARGUMENTS - END
6917+ uint64_t return_to = 18446744073709551361LLU;
6918+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6919+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6920+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6921+ heap.data[0].elem1 = heap.data[0].elem0;
6922+ heap.data[0].elem0 = restore;
6923+ state.addr = 325750391286068249LLU; // RESDEFCOPY
6924+ break;
6925+ }
6926+ case 18446744073709551361LLU: // 999999996A'''''''''''''''
6927+ {
6928+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551364LLU : 18446744073709551363LLU;
6929+ break;
6930+ }
6931+ case 18446744073709551364LLU: // 999999996D'''''''''''''''
6932+ {
6933+ {
6934+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
6935+ exit(-1);
6936+ }
6937+ // emitted destructur for type resdest___
6938+ // ACCUMULATE ARGUMENTS - BEGIN
6939+ {
6940+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
6941+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6942+ }
6943+ // ACCUMULATE ARGUMENTS - END
6944+ uint64_t return_to = 18446744073709551360LLU;
6945+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6946+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6947+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6948+ heap.data[0].elem1 = heap.data[0].elem0;
6949+ heap.data[0].elem0 = restore;
6950+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6951+ break;
6952+ }
6953+ case 18446744073709551360LLU: // 999999996_'''''''''''''''
6954+ {
6955+ // parameter resdest___ new_______ goes out of scope
6956+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
6957+ break;
6958+ }
6959+ case 18446744073709551363LLU: // 999999996C'''''''''''''''
6960+ {
6961+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
6962+ break;
6963+ }
6964+ case 18446744073709551362LLU: // 999999996B'''''''''''''''
6965+ {
6966+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9
6967+ // parameter-reference resdest___ respar1___ goes out of scope
6968+ // parameter-reference list<resdest___> yresults__ goes out of scope
6969+ state.addr = 18446744073709551366LLU; // 999999996F'''''''''''''''
6970+ break;
6971+ }
6972+ case 18446744073709551365LLU: // 999999996E'''''''''''''''
6973+ {
6974+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
6975+ {
6976+ uint64_t arg = /*xresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU));
6977+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6978+ }
6979+ {
6980+ uint64_t arg = 0;
6981+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6982+ }
6983+ state.addr = 18446744073709551359LLU; // 9999999959'''''''''''''''
6984+ break;
6985+ }
6986+ case 18446744073709551359LLU: // 9999999959'''''''''''''''
6987+ {
6988+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
6989+ {
6990+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
6991+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
6992+ {
6993+ state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
6994+ break;
6995+ }
6996+ }
6997+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
6998+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
6999+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551357LLU : 18446744073709551356LLU;
7000+ break;
7001+ }
7002+ case 18446744073709551357LLU: // 9999999957'''''''''''''''
7003+ {
7004+ {
7005+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 8);
7006+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7007+ }
7008+ {
7009+ uint64_t arg = 0;
7010+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7011+ }
7012+ *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 0;
7013+ // ACCUMULATE ARGUMENTS - BEGIN
7014+ {
7015+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
7016+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7017+ }
7018+ {
7019+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
7020+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7021+ }
7022+ {
7023+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 8LLU);
7024+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7025+ }
7026+ // ACCUMULATE ARGUMENTS - END
7027+ uint64_t return_to = 18446744073709551354LLU;
7028+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7029+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7030+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7031+ heap.data[0].elem1 = heap.data[0].elem0;
7032+ heap.data[0].elem0 = restore;
7033+ state.addr = 589059885019168768LLU; // equres____
7034+ break;
7035+ }
7036+ case 18446744073709551354LLU: // 9999999954'''''''''''''''
7037+ {
7038+
7039+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU);
7040+ // variable u64 EQUAL_____ goes out of scope
7041+ // emitted destructur for type u64
7042+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 10
7043+ // variable resdest___ res1______ goes out of scope
7044+ // emitted destructur for type resdest___
7045+ // ACCUMULATE ARGUMENTS - BEGIN
7046+ {
7047+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7048+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7049+ }
7050+ // ACCUMULATE ARGUMENTS - END
7051+ uint64_t return_to = 18446744073709551353LLU;
7052+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7053+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7054+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7055+ heap.data[0].elem1 = heap.data[0].elem0;
7056+ heap.data[0].elem0 = restore;
7057+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7058+ break;
7059+ }
7060+ case 18446744073709551353LLU: // 9999999953'''''''''''''''
7061+ {
7062+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 9
7063+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
7064+ break;
7065+ }
7066+ case 18446744073709551356LLU: // 9999999956'''''''''''''''
7067+ {
7068+
7069+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7070+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
7071+ break;
7072+ }
7073+ case 18446744073709551355LLU: // 9999999955'''''''''''''''
7074+ {
7075+ // parameter-reference resdest___ res0______ goes out of scope
7076+ // parameter-reference list<resdest___> xresults__ goes out of scope
7077+ state.addr = 18446744073709551359LLU; // 9999999959'''''''''''''''
7078+ break;
7079+ }
7080+ case 18446744073709551358LLU: // 9999999958'''''''''''''''
7081+ {
7082+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551352LLU : 18446744073709551351LLU;
7083+ break;
7084+ }
7085+ case 18446744073709551352LLU: // 9999999952'''''''''''''''
7086+ {
7087+ {
7088+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8);
7089+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7090+ }
7091+
7092+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 0;
7093+ // variable resdest___ res1______ goes out of scope
7094+ // emitted destructur for type resdest___
7095+ // ACCUMULATE ARGUMENTS - BEGIN
7096+ {
7097+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7098+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7099+ }
7100+ // ACCUMULATE ARGUMENTS - END
7101+ uint64_t return_to = 18446744073709551349LLU;
7102+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7103+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7104+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7105+ heap.data[0].elem1 = heap.data[0].elem0;
7106+ heap.data[0].elem0 = restore;
7107+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7108+ break;
7109+ }
7110+ case 18446744073709551349LLU: // 999999995z'''''''''''''''
7111+ {
7112+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7
7113+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
7114+ break;
7115+ }
7116+ case 18446744073709551351LLU: // 9999999951'''''''''''''''
7117+ {
7118+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
7119+ break;
7120+ }
7121+ case 18446744073709551350LLU: // 9999999950'''''''''''''''
7122+ {
7123+ // variable list<resdest___> yres______ goes out of scope
7124+ // emitted destructur for type list<resdest___>
7125+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7126+ break;
7127+ }
7128+ case 18446744073709551347LLU: // 999999995x'''''''''''''''
7129+ {
7130+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/)
7131+ {
7132+ state.addr = 18446744073709551348LLU; // 999999995y'''''''''''''''
7133+ break;
7134+ }
7135+ // temporary list-element
7136+ {
7137+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8);
7138+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7139+ }
7140+ // ACCUMULATE ARGUMENTS - BEGIN
7141+ {
7142+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7143+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7144+ }
7145+ // ACCUMULATE ARGUMENTS - END
7146+ uint64_t return_to = 18446744073709551346LLU;
7147+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7148+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7149+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7150+ heap.data[0].elem1 = heap.data[0].elem0;
7151+ heap.data[0].elem0 = restore;
7152+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7153+ break;
7154+ }
7155+ case 18446744073709551346LLU: // 999999995w'''''''''''''''
7156+ {
7157+ // RELEASE temporary destructor-variable
7158+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7159+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7160+ break;
7161+ }
7162+ case 18446744073709551348LLU: // 999999995y'''''''''''''''
7163+ {
7164+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 6
7165+ {
7166+ uint64_t arg = 0;
7167+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7168+ }
7169+ {
7170+ uint64_t arg = /*ydefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
7171+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7172+ }
7173+ {
7174+ uint64_t arg = 0;
7175+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7176+ }
7177+ state.addr = 18446744073709551345LLU; // 999999995v'''''''''''''''
7178+ break;
7179+ }
7180+ case 18446744073709551345LLU: // 999999995v'''''''''''''''
7181+ {
7182+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7183+ {
7184+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7185+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7186+ {
7187+ state.addr = 18446744073709551344LLU; // 999999995u'''''''''''''''
7188+ break;
7189+ }
7190+ }
7191+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7192+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7193+ {
7194+ uint64_t arg = 0;
7195+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7196+ }
7197+ // ACCUMULATE ARGUMENTS - BEGIN
7198+ {
7199+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7200+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7201+ }
7202+ {
7203+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
7204+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7205+ }
7206+ // ACCUMULATE ARGUMENTS - END
7207+ uint64_t return_to = 18446744073709551340LLU;
7208+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7209+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7210+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7211+ heap.data[0].elem1 = heap.data[0].elem0;
7212+ heap.data[0].elem0 = restore;
7213+ state.addr = 296309897384864500LLU; // ParDefCopy
7214+ break;
7215+ }
7216+ case 18446744073709551340LLU: // 999999995q'''''''''''''''
7217+ {
7218+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551343LLU : 18446744073709551342LLU;
7219+ break;
7220+ }
7221+ case 18446744073709551343LLU: // 999999995t'''''''''''''''
7222+ {
7223+ {
7224+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7225+ exit(-1);
7226+ }
7227+ // emitted destructur for type pardef____
7228+ // ACCUMULATE ARGUMENTS - BEGIN
7229+ {
7230+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7231+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7232+ }
7233+ // ACCUMULATE ARGUMENTS - END
7234+ uint64_t return_to = 18446744073709551339LLU;
7235+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7236+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7237+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7238+ heap.data[0].elem1 = heap.data[0].elem0;
7239+ heap.data[0].elem0 = restore;
7240+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7241+ break;
7242+ }
7243+ case 18446744073709551339LLU: // 999999995p'''''''''''''''
7244+ {
7245+ // parameter pardef____ new_______ goes out of scope
7246+ state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
7247+ break;
7248+ }
7249+ case 18446744073709551342LLU: // 999999995s'''''''''''''''
7250+ {
7251+ state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
7252+ break;
7253+ }
7254+ case 18446744073709551341LLU: // 999999995r'''''''''''''''
7255+ {
7256+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9
7257+ // parameter-reference pardef____ par1______ goes out of scope
7258+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
7259+ state.addr = 18446744073709551345LLU; // 999999995v'''''''''''''''
7260+ break;
7261+ }
7262+ case 18446744073709551344LLU: // 999999995u'''''''''''''''
7263+ {
7264+ list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
7265+ {
7266+ uint64_t arg = /*xdefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU));
7267+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7268+ }
7269+ {
7270+ uint64_t arg = 0;
7271+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7272+ }
7273+ state.addr = 18446744073709551338LLU; // 999999995o'''''''''''''''
7274+ break;
7275+ }
7276+ case 18446744073709551338LLU: // 999999995o'''''''''''''''
7277+ {
7278+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7279+ {
7280+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7281+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7282+ {
7283+ state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
7284+ break;
7285+ }
7286+ }
7287+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7288+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7289+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551336LLU : 18446744073709551335LLU;
7290+ break;
7291+ }
7292+ case 18446744073709551336LLU: // 999999995m'''''''''''''''
7293+ {
7294+ {
7295+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 11);
7296+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7297+ }
7298+ {
7299+ uint64_t arg = 0;
7300+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7301+ }
7302+ *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 0;
7303+ // ACCUMULATE ARGUMENTS - BEGIN
7304+ {
7305+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
7306+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7307+ }
7308+ {
7309+ uint64_t arg = /*par0______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
7310+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7311+ }
7312+ {
7313+ uint64_t arg = /*par1______*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 8LLU);
7314+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7315+ }
7316+ // ACCUMULATE ARGUMENTS - END
7317+ uint64_t return_to = 18446744073709551333LLU;
7318+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7319+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7320+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7321+ heap.data[0].elem1 = heap.data[0].elem0;
7322+ heap.data[0].elem0 = restore;
7323+ state.addr = 589059743276730432LLU; // equpardef_
7324+ break;
7325+ }
7326+ case 18446744073709551333LLU: // 999999995j'''''''''''''''
7327+ {
7328+
7329+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU);
7330+ // variable u64 EQUAL_____ goes out of scope
7331+ // emitted destructur for type u64
7332+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 10
7333+ // variable pardef____ par1______ goes out of scope
7334+ // emitted destructur for type pardef____
7335+ // ACCUMULATE ARGUMENTS - BEGIN
7336+ {
7337+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7338+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7339+ }
7340+ // ACCUMULATE ARGUMENTS - END
7341+ uint64_t return_to = 18446744073709551332LLU;
7342+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7343+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7344+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7345+ heap.data[0].elem1 = heap.data[0].elem0;
7346+ heap.data[0].elem0 = restore;
7347+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7348+ break;
7349+ }
7350+ case 18446744073709551332LLU: // 999999995i'''''''''''''''
7351+ {
7352+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 9
7353+ state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
7354+ break;
7355+ }
7356+ case 18446744073709551335LLU: // 999999995l'''''''''''''''
7357+ {
7358+
7359+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7360+ state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
7361+ break;
7362+ }
7363+ case 18446744073709551334LLU: // 999999995k'''''''''''''''
7364+ {
7365+ // parameter-reference pardef____ par0______ goes out of scope
7366+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
7367+ state.addr = 18446744073709551338LLU; // 999999995o'''''''''''''''
7368+ break;
7369+ }
7370+ case 18446744073709551337LLU: // 999999995n'''''''''''''''
7371+ {
7372+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551331LLU : 18446744073709551330LLU;
7373+ break;
7374+ }
7375+ case 18446744073709551331LLU: // 999999995h'''''''''''''''
7376+ {
7377+ {
7378+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11);
7379+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7380+ }
7381+
7382+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 0;
7383+ // variable pardef____ par1______ goes out of scope
7384+ // emitted destructur for type pardef____
7385+ // ACCUMULATE ARGUMENTS - BEGIN
7386+ {
7387+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7388+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7389+ }
7390+ // ACCUMULATE ARGUMENTS - END
7391+ uint64_t return_to = 18446744073709551328LLU;
7392+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7393+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7394+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7395+ heap.data[0].elem1 = heap.data[0].elem0;
7396+ heap.data[0].elem0 = restore;
7397+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7398+ break;
7399+ }
7400+ case 18446744073709551328LLU: // 999999995e'''''''''''''''
7401+ {
7402+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7
7403+ state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
7404+ break;
7405+ }
7406+ case 18446744073709551330LLU: // 999999995g'''''''''''''''
7407+ {
7408+ state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
7409+ break;
7410+ }
7411+ case 18446744073709551329LLU: // 999999995f'''''''''''''''
7412+ {
7413+ // variable list<pardef____> ypars_____ goes out of scope
7414+ // emitted destructur for type list<pardef____>
7415+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7416+ break;
7417+ }
7418+ case 18446744073709551326LLU: // 999999995c'''''''''''''''
7419+ {
7420+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/)
7421+ {
7422+ state.addr = 18446744073709551327LLU; // 999999995d'''''''''''''''
7423+ break;
7424+ }
7425+ // temporary list-element
7426+ {
7427+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11);
7428+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7429+ }
7430+ // ACCUMULATE ARGUMENTS - BEGIN
7431+ {
7432+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7433+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7434+ }
7435+ // ACCUMULATE ARGUMENTS - END
7436+ uint64_t return_to = 18446744073709551325LLU;
7437+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7438+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7439+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7440+ heap.data[0].elem1 = heap.data[0].elem0;
7441+ heap.data[0].elem0 = restore;
7442+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7443+ break;
7444+ }
7445+ case 18446744073709551325LLU: // 999999995b'''''''''''''''
7446+ {
7447+ // RELEASE temporary destructor-variable
7448+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7449+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7450+ break;
7451+ }
7452+ case 18446744073709551327LLU: // 999999995d'''''''''''''''
7453+ {
7454+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 6
7455+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
7456+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefpars__ at 5
7457+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
7458+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefpars__ at 4
7459+ // parameter-reference list<resdest___> yresults__ goes out of scope
7460+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yresults__ at 3
7461+ // parameter-reference list<resdest___> xresults__ goes out of scope
7462+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xresults__ at 2
7463+ // parameter-reference u64 equal_____ goes out of scope
7464+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
7465+ {
7466+ uint64_t baseinfo = heap.data[0].elem1;
7467+ struct pair pair = unpair(&heap, &baseinfo);
7468+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7469+ state.addr = pair.elem1;
7470+ }
7471+ break;
7472+ }
7473+ case 94949853545914368LLU: // EQUFNDEF__
7474+ {
7475+
7476+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = 1;
7477+ {
7478+ uint64_t arg = 0;
7479+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7480+ }
7481+ {
7482+ uint64_t arg = /*yresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 2LLU));
7483+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7484+ }
7485+ {
7486+ uint64_t arg = 0;
7487+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7488+ }
7489+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
7490+ break;
7491+ }
7492+ case 18446744073709551324LLU: // 999999995a'''''''''''''''
7493+ {
7494+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7495+ {
7496+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7497+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7498+ {
7499+ state.addr = 18446744073709551323LLU; // 999999995$'''''''''''''''
7500+ break;
7501+ }
7502+ }
7503+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7504+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7505+ {
7506+ uint64_t arg = 0;
7507+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7508+ }
7509+ // ACCUMULATE ARGUMENTS - BEGIN
7510+ {
7511+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7512+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7513+ }
7514+ {
7515+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU);
7516+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7517+ }
7518+ // ACCUMULATE ARGUMENTS - END
7519+ uint64_t return_to = 18446744073709551319LLU;
7520+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7521+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7522+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7523+ heap.data[0].elem1 = heap.data[0].elem0;
7524+ heap.data[0].elem0 = restore;
7525+ state.addr = 325750391286068249LLU; // RESDEFCOPY
7526+ break;
7527+ }
7528+ case 18446744073709551319LLU: // 999999995W'''''''''''''''
7529+ {
7530+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551322LLU : 18446744073709551321LLU;
7531+ break;
7532+ }
7533+ case 18446744073709551322LLU: // 999999995Z'''''''''''''''
7534+ {
7535+ {
7536+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7537+ exit(-1);
7538+ }
7539+ // emitted destructur for type resdest___
7540+ // ACCUMULATE ARGUMENTS - BEGIN
7541+ {
7542+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7543+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7544+ }
7545+ // ACCUMULATE ARGUMENTS - END
7546+ uint64_t return_to = 18446744073709551318LLU;
7547+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7548+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7549+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7550+ heap.data[0].elem1 = heap.data[0].elem0;
7551+ heap.data[0].elem0 = restore;
7552+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7553+ break;
7554+ }
7555+ case 18446744073709551318LLU: // 999999995V'''''''''''''''
7556+ {
7557+ // parameter resdest___ new_______ goes out of scope
7558+ state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
7559+ break;
7560+ }
7561+ case 18446744073709551321LLU: // 999999995Y'''''''''''''''
7562+ {
7563+ state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
7564+ break;
7565+ }
7566+ case 18446744073709551320LLU: // 999999995X'''''''''''''''
7567+ {
7568+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
7569+ // parameter-reference resdest___ respar1___ goes out of scope
7570+ // parameter-reference list<resdest___> yresults__ goes out of scope
7571+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
7572+ break;
7573+ }
7574+ case 18446744073709551323LLU: // 999999995$'''''''''''''''
7575+ {
7576+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
7577+ {
7578+ uint64_t arg = /*xresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 1LLU));
7579+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7580+ }
7581+ {
7582+ uint64_t arg = 0;
7583+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7584+ }
7585+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
7586+ break;
7587+ }
7588+ case 18446744073709551317LLU: // 999999995U'''''''''''''''
7589+ {
7590+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7591+ {
7592+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7593+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7594+ {
7595+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
7596+ break;
7597+ }
7598+ }
7599+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7600+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7601+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551315LLU : 18446744073709551314LLU;
7602+ break;
7603+ }
7604+ case 18446744073709551315LLU: // 999999995S'''''''''''''''
7605+ {
7606+ {
7607+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 8);
7608+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7609+ }
7610+ {
7611+ uint64_t arg = 0;
7612+ LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7613+ }
7614+ *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
7615+ // ACCUMULATE ARGUMENTS - BEGIN
7616+ {
7617+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
7618+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7619+ }
7620+ {
7621+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU);
7622+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7623+ }
7624+ {
7625+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 18LLU);
7626+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7627+ }
7628+ // ACCUMULATE ARGUMENTS - END
7629+ uint64_t return_to = 18446744073709551312LLU;
7630+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7631+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7632+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7633+ heap.data[0].elem1 = heap.data[0].elem0;
7634+ heap.data[0].elem0 = restore;
7635+ state.addr = 589059885019168768LLU; // equres____
7636+ break;
7637+ }
7638+ case 18446744073709551312LLU: // 999999995P'''''''''''''''
7639+ {
7640+
7641+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
7642+ // variable u64 EQUAL_____ goes out of scope
7643+ // emitted destructur for type u64
7644+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 20
7645+ // variable resdest___ res1______ goes out of scope
7646+ // emitted destructur for type resdest___
7647+ // ACCUMULATE ARGUMENTS - BEGIN
7648+ {
7649+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7650+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7651+ }
7652+ // ACCUMULATE ARGUMENTS - END
7653+ uint64_t return_to = 18446744073709551311LLU;
7654+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7655+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7656+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7657+ heap.data[0].elem1 = heap.data[0].elem0;
7658+ heap.data[0].elem0 = restore;
7659+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7660+ break;
7661+ }
7662+ case 18446744073709551311LLU: // 999999995O'''''''''''''''
7663+ {
7664+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 19
7665+ state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
7666+ break;
7667+ }
7668+ case 18446744073709551314LLU: // 999999995R'''''''''''''''
7669+ {
7670+
7671+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
7672+ state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
7673+ break;
7674+ }
7675+ case 18446744073709551313LLU: // 999999995Q'''''''''''''''
7676+ {
7677+ // parameter-reference resdest___ res0______ goes out of scope
7678+ // parameter-reference list<resdest___> xresults__ goes out of scope
7679+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
7680+ break;
7681+ }
7682+ case 18446744073709551316LLU: // 999999995T'''''''''''''''
7683+ {
7684+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551310LLU : 18446744073709551309LLU;
7685+ break;
7686+ }
7687+ case 18446744073709551310LLU: // 999999995N'''''''''''''''
7688+ {
7689+ {
7690+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8);
7691+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7692+ }
7693+
7694+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)) = 0;
7695+ // variable resdest___ res1______ goes out of scope
7696+ // emitted destructur for type resdest___
7697+ // ACCUMULATE ARGUMENTS - BEGIN
7698+ {
7699+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
7700+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7701+ }
7702+ // ACCUMULATE ARGUMENTS - END
7703+ uint64_t return_to = 18446744073709551307LLU;
7704+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7705+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7706+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7707+ heap.data[0].elem1 = heap.data[0].elem0;
7708+ heap.data[0].elem0 = restore;
7709+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7710+ break;
7711+ }
7712+ case 18446744073709551307LLU: // 999999995K'''''''''''''''
7713+ {
7714+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 17
7715+ state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
7716+ break;
7717+ }
7718+ case 18446744073709551309LLU: // 999999995M'''''''''''''''
7719+ {
7720+ state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
7721+ break;
7722+ }
7723+ case 18446744073709551308LLU: // 999999995L'''''''''''''''
7724+ {
7725+ // variable list<resdest___> yres______ goes out of scope
7726+ // emitted destructur for type list<resdest___>
7727+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
7728+ break;
7729+ }
7730+ case 18446744073709551305LLU: // 999999995I'''''''''''''''
7731+ {
7732+ if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/)
7733+ {
7734+ state.addr = 18446744073709551306LLU; // 999999995J'''''''''''''''
7735+ break;
7736+ }
7737+ // temporary list-element
7738+ {
7739+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8);
7740+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7741+ }
7742+ // ACCUMULATE ARGUMENTS - BEGIN
7743+ {
7744+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
7745+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7746+ }
7747+ // ACCUMULATE ARGUMENTS - END
7748+ uint64_t return_to = 18446744073709551304LLU;
7749+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7750+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7751+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7752+ heap.data[0].elem1 = heap.data[0].elem0;
7753+ heap.data[0].elem0 = restore;
7754+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7755+ break;
7756+ }
7757+ case 18446744073709551304LLU: // 999999995H'''''''''''''''
7758+ {
7759+ // RELEASE temporary destructor-variable
7760+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7761+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
7762+ break;
7763+ }
7764+ case 18446744073709551306LLU: // 999999995J'''''''''''''''
7765+ {
7766+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 16
7767+ {
7768+ uint64_t arg = 0;
7769+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7770+ }
7771+ {
7772+ uint64_t arg = /*ydefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 4LLU));
7773+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7774+ }
7775+ {
7776+ uint64_t arg = 0;
7777+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7778+ }
7779+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
7780+ break;
7781+ }
7782+ case 18446744073709551303LLU: // 999999995G'''''''''''''''
7783+ {
7784+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7785+ {
7786+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7787+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7788+ {
7789+ state.addr = 18446744073709551302LLU; // 999999995F'''''''''''''''
7790+ break;
7791+ }
7792+ }
7793+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7794+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7795+ {
7796+ uint64_t arg = 0;
7797+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7798+ }
7799+ // ACCUMULATE ARGUMENTS - BEGIN
7800+ {
7801+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7802+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7803+ }
7804+ {
7805+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU);
7806+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7807+ }
7808+ // ACCUMULATE ARGUMENTS - END
7809+ uint64_t return_to = 18446744073709551298LLU;
7810+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7811+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7812+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7813+ heap.data[0].elem1 = heap.data[0].elem0;
7814+ heap.data[0].elem0 = restore;
7815+ state.addr = 296309897384864500LLU; // ParDefCopy
7816+ break;
7817+ }
7818+ case 18446744073709551298LLU: // 999999995B'''''''''''''''
7819+ {
7820+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551301LLU : 18446744073709551300LLU;
7821+ break;
7822+ }
7823+ case 18446744073709551301LLU: // 999999995E'''''''''''''''
7824+ {
7825+ {
7826+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7827+ exit(-1);
7828+ }
7829+ // emitted destructur for type pardef____
7830+ // ACCUMULATE ARGUMENTS - BEGIN
7831+ {
7832+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7833+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7834+ }
7835+ // ACCUMULATE ARGUMENTS - END
7836+ uint64_t return_to = 18446744073709551297LLU;
7837+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7838+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7839+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7840+ heap.data[0].elem1 = heap.data[0].elem0;
7841+ heap.data[0].elem0 = restore;
7842+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7843+ break;
7844+ }
7845+ case 18446744073709551297LLU: // 999999995A'''''''''''''''
7846+ {
7847+ // parameter pardef____ new_______ goes out of scope
7848+ state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
7849+ break;
7850+ }
7851+ case 18446744073709551300LLU: // 999999995D'''''''''''''''
7852+ {
7853+ state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
7854+ break;
7855+ }
7856+ case 18446744073709551299LLU: // 999999995C'''''''''''''''
7857+ {
7858+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
7859+ // parameter-reference pardef____ par1______ goes out of scope
7860+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
7861+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
7862+ break;
7863+ }
7864+ case 18446744073709551302LLU: // 999999995F'''''''''''''''
7865+ {
7866+ list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
7867+ {
7868+ uint64_t arg = /*xdefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 3LLU));
7869+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7870+ }
7871+ {
7872+ uint64_t arg = 0;
7873+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7874+ }
7875+ state.addr = 18446744073709551296LLU; // 999999995_'''''''''''''''
7876+ break;
7877+ }
7878+ case 18446744073709551296LLU: // 999999995_'''''''''''''''
7879+ {
7880+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7881+ {
7882+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7883+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7884+ {
7885+ state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
7886+ break;
7887+ }
7888+ }
7889+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7890+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7891+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551294LLU : 18446744073709551293LLU;
7892+ break;
7893+ }
7894+ case 18446744073709551294LLU: // 9999999948'''''''''''''''
7895+ {
7896+ {
7897+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 11);
7898+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7899+ }
7900+ {
7901+ uint64_t arg = 0;
7902+ LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7903+ }
7904+ *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
7905+ // ACCUMULATE ARGUMENTS - BEGIN
7906+ {
7907+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
7908+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7909+ }
7910+ {
7911+ uint64_t arg = /*par0______*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU);
7912+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7913+ }
7914+ {
7915+ uint64_t arg = /*par1______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 18LLU);
7916+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7917+ }
7918+ // ACCUMULATE ARGUMENTS - END
7919+ uint64_t return_to = 18446744073709551291LLU;
7920+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7921+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7922+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7923+ heap.data[0].elem1 = heap.data[0].elem0;
7924+ heap.data[0].elem0 = restore;
7925+ state.addr = 589059743276730432LLU; // equpardef_
7926+ break;
7927+ }
7928+ case 18446744073709551291LLU: // 9999999945'''''''''''''''
7929+ {
7930+
7931+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU);
7932+ // variable u64 EQUAL_____ goes out of scope
7933+ // emitted destructur for type u64
7934+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 20
7935+ // variable pardef____ par1______ goes out of scope
7936+ // emitted destructur for type pardef____
7937+ // ACCUMULATE ARGUMENTS - BEGIN
7938+ {
7939+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7940+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7941+ }
7942+ // ACCUMULATE ARGUMENTS - END
7943+ uint64_t return_to = 18446744073709551290LLU;
7944+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7945+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7946+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7947+ heap.data[0].elem1 = heap.data[0].elem0;
7948+ heap.data[0].elem0 = restore;
7949+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
7950+ break;
7951+ }
7952+ case 18446744073709551290LLU: // 9999999944'''''''''''''''
7953+ {
7954+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 19
7955+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
7956+ break;
7957+ }
7958+ case 18446744073709551293LLU: // 9999999947'''''''''''''''
7959+ {
7960+
7961+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
7962+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
7963+ break;
7964+ }
7965+ case 18446744073709551292LLU: // 9999999946'''''''''''''''
7966+ {
7967+ // parameter-reference pardef____ par0______ goes out of scope
7968+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
7969+ state.addr = 18446744073709551296LLU; // 999999995_'''''''''''''''
7970+ break;
7971+ }
7972+ case 18446744073709551295LLU: // 9999999949'''''''''''''''
7973+ {
7974+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551289LLU : 18446744073709551288LLU;
7975+ break;
7976+ }
7977+ case 18446744073709551289LLU: // 9999999943'''''''''''''''
7978+ {
7979+ {
7980+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11);
7981+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7982+ }
7983+
7984+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)) = 0;
7985+ // variable pardef____ par1______ goes out of scope
7986+ // emitted destructur for type pardef____
7987+ // ACCUMULATE ARGUMENTS - BEGIN
7988+ {
7989+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
7990+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7991+ }
7992+ // ACCUMULATE ARGUMENTS - END
7993+ uint64_t return_to = 18446744073709551286LLU;
7994+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7995+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7996+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7997+ heap.data[0].elem1 = heap.data[0].elem0;
7998+ heap.data[0].elem0 = restore;
7999+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8000+ break;
8001+ }
8002+ case 18446744073709551286LLU: // 9999999940'''''''''''''''
8003+ {
8004+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 17
8005+ state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
8006+ break;
8007+ }
8008+ case 18446744073709551288LLU: // 9999999942'''''''''''''''
8009+ {
8010+ state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
8011+ break;
8012+ }
8013+ case 18446744073709551287LLU: // 9999999941'''''''''''''''
8014+ {
8015+ // variable list<pardef____> ypars_____ goes out of scope
8016+ // emitted destructur for type list<pardef____>
8017+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8018+ break;
8019+ }
8020+ case 18446744073709551284LLU: // 999999994y'''''''''''''''
8021+ {
8022+ if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/)
8023+ {
8024+ state.addr = 18446744073709551285LLU; // 999999994z'''''''''''''''
8025+ break;
8026+ }
8027+ // temporary list-element
8028+ {
8029+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11);
8030+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8031+ }
8032+ // ACCUMULATE ARGUMENTS - BEGIN
8033+ {
8034+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
8035+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8036+ }
8037+ // ACCUMULATE ARGUMENTS - END
8038+ uint64_t return_to = 18446744073709551283LLU;
8039+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8040+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8041+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8042+ heap.data[0].elem1 = heap.data[0].elem0;
8043+ heap.data[0].elem0 = restore;
8044+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8045+ break;
8046+ }
8047+ case 18446744073709551283LLU: // 999999994x'''''''''''''''
8048+ {
8049+ // RELEASE temporary destructor-variable
8050+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
8051+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8052+ break;
8053+ }
8054+ case 18446744073709551285LLU: // 999999994z'''''''''''''''
8055+ {
8056+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 16
8057+ {
8058+ uint64_t arg = 0;
8059+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8060+ }
8061+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = /*xsizeoheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) == /*ysizeoheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 6LLU));
8062+
8063+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
8064+ // variable u64 EQUAL_____ goes out of scope
8065+ // emitted destructur for type u64
8066+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8067+ {
8068+ uint64_t arg = 0;
8069+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8070+ }
8071+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = /*xdefbodysz*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 7LLU)) == /*ydefbodysz*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 8LLU));
8072+
8073+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
8074+ // variable u64 EQUAL_____ goes out of scope
8075+ // emitted destructur for type u64
8076+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8077+ {
8078+ uint64_t arg = 0;
8079+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8080+ }
8081+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = /*xcomplete_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 9LLU)) == /*ycomplete_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 10LLU));
8082+
8083+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
8084+ // variable u64 EQUAL_____ goes out of scope
8085+ // emitted destructur for type u64
8086+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8087+ {
8088+ uint64_t arg = 0;
8089+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8090+ }
8091+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = /*xfinite___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 11LLU)) == /*yfinite___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 12LLU));
8092+
8093+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
8094+ // variable u64 EQUAL_____ goes out of scope
8095+ // emitted destructur for type u64
8096+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8097+ {
8098+ uint64_t arg = 0;
8099+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8100+ }
8101+ *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = /*xsafe_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 13LLU)) == /*ysafe_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 14LLU));
8102+
8103+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU);
8104+ // variable u64 EQUAL_____ goes out of scope
8105+ // emitted destructur for type u64
8106+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8107+ // parameter-reference u64 ysafe_____ goes out of scope
8108+ (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ysafe_____ at 15
8109+ // parameter-reference u64 xsafe_____ goes out of scope
8110+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xsafe_____ at 14
8111+ // parameter-reference u64 yfinite___ goes out of scope
8112+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yfinite___ at 13
8113+ // parameter-reference u64 xfinite___ goes out of scope
8114+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xfinite___ at 12
8115+ // parameter-reference u64 ycomplete_ goes out of scope
8116+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ycomplete_ at 11
8117+ // parameter-reference u64 xcomplete_ goes out of scope
8118+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xcomplete_ at 10
8119+ // parameter-reference u64 ydefbodysz goes out of scope
8120+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefbodysz at 9
8121+ // parameter-reference u64 xdefbodysz goes out of scope
8122+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefbodysz at 8
8123+ // parameter-reference u64 ysizeoheap goes out of scope
8124+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ysizeoheap at 7
8125+ // parameter-reference u64 xsizeoheap goes out of scope
8126+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xsizeoheap at 6
8127+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
8128+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefpars__ at 5
8129+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
8130+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefpars__ at 4
8131+ // parameter-reference list<resdest___> yresults__ goes out of scope
8132+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yresults__ at 3
8133+ // parameter-reference list<resdest___> xresults__ goes out of scope
8134+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xresults__ at 2
8135+ // parameter-reference u64 equal_____ goes out of scope
8136+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
8137+ {
8138+ uint64_t baseinfo = heap.data[0].elem1;
8139+ struct pair pair = unpair(&heap, &baseinfo);
8140+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
8141+ state.addr = pair.elem1;
8142+ }
8143+ break;
8144+ }
8145+ case 589059069805989888LLU: // equfndef__
8146+ {
8147+
8148+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1;
8149+ {
8150+ uint64_t arg = 0;
8151+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8152+ }
8153+ {
8154+ uint64_t arg = /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 0LLU));
8155+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8156+ }
8157+ {
8158+ uint64_t arg = 0;
8159+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8160+ }
8161+ state.addr = 18446744073709551282LLU; // 999999994w'''''''''''''''
8162+ break;
8163+ }
8164+ case 18446744073709551282LLU: // 999999994w'''''''''''''''
8165+ {
8166+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8167+ {
8168+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8169+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8170+ {
8171+ state.addr = 18446744073709551281LLU; // 999999994v'''''''''''''''
8172+ break;
8173+ }
8174+ }
8175+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8176+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8177+ {
8178+ uint64_t arg = 0;
8179+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8180+ }
8181+ // ACCUMULATE ARGUMENTS - BEGIN
8182+ {
8183+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8184+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8185+ }
8186+ {
8187+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
8188+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8189+ }
8190+ // ACCUMULATE ARGUMENTS - END
8191+ uint64_t return_to = 18446744073709551277LLU;
8192+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
8193+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8194+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8195+ heap.data[0].elem1 = heap.data[0].elem0;
8196+ heap.data[0].elem0 = restore;
8197+ state.addr = 325750391286068249LLU; // RESDEFCOPY
8198+ break;
8199+ }
8200+ case 18446744073709551277LLU: // 999999994r'''''''''''''''
8201+ {
8202+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551280LLU : 18446744073709551279LLU;
8203+ break;
8204+ }
8205+ case 18446744073709551280LLU: // 999999994u'''''''''''''''
8206+ {
8207+ {
8208+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
8209+ exit(-1);
8210+ }
8211+ // emitted destructur for type resdest___
8212+ // ACCUMULATE ARGUMENTS - BEGIN
8213+ {
8214+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8215+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8216+ }
8217+ // ACCUMULATE ARGUMENTS - END
8218+ uint64_t return_to = 18446744073709551276LLU;
8219+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8220+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8221+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8222+ heap.data[0].elem1 = heap.data[0].elem0;
8223+ heap.data[0].elem0 = restore;
8224+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8225+ break;
8226+ }
8227+ case 18446744073709551276LLU: // 999999994q'''''''''''''''
8228+ {
8229+ // parameter resdest___ new_______ goes out of scope
8230+ state.addr = 18446744073709551278LLU; // 999999994s'''''''''''''''
8231+ break;
8232+ }
8233+ case 18446744073709551279LLU: // 999999994t'''''''''''''''
8234+ {
8235+ state.addr = 18446744073709551278LLU; // 999999994s'''''''''''''''
8236+ break;
8237+ }
8238+ case 18446744073709551278LLU: // 999999994s'''''''''''''''
8239+ {
8240+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
8241+ // parameter-reference resdest___ respar1___ goes out of scope
8242+ // parameter-reference function__ y_________ goes out of scope
8243+ state.addr = 18446744073709551282LLU; // 999999994w'''''''''''''''
8244+ break;
8245+ }
8246+ case 18446744073709551281LLU: // 999999994v'''''''''''''''
8247+ {
8248+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
8249+ {
8250+ uint64_t arg = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU));
8251+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8252+ }
8253+ {
8254+ uint64_t arg = 0;
8255+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8256+ }
8257+ state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
8258+ break;
8259+ }
8260+ case 18446744073709551275LLU: // 999999994p'''''''''''''''
8261+ {
8262+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8263+ {
8264+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8265+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8266+ {
8267+ state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
8268+ break;
8269+ }
8270+ }
8271+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8272+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8273+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551273LLU : 18446744073709551272LLU;
8274+ break;
8275+ }
8276+ case 18446744073709551273LLU: // 999999994n'''''''''''''''
8277+ {
8278+ {
8279+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 8);
8280+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8281+ }
8282+ {
8283+ uint64_t arg = 0;
8284+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8285+ }
8286+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = 0;
8287+ // ACCUMULATE ARGUMENTS - BEGIN
8288+ {
8289+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
8290+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8291+ }
8292+ {
8293+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
8294+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8295+ }
8296+ {
8297+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 6LLU);
8298+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8299+ }
8300+ // ACCUMULATE ARGUMENTS - END
8301+ uint64_t return_to = 18446744073709551270LLU;
8302+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
8303+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8304+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8305+ heap.data[0].elem1 = heap.data[0].elem0;
8306+ heap.data[0].elem0 = restore;
8307+ state.addr = 589059885019168768LLU; // equres____
8308+ break;
8309+ }
8310+ case 18446744073709551270LLU: // 999999994k'''''''''''''''
8311+ {
8312+
8313+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);
8314+ // variable u64 EQUAL_____ goes out of scope
8315+ // emitted destructur for type u64
8316+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 8
8317+ // variable resdest___ res1______ goes out of scope
8318+ // emitted destructur for type resdest___
8319+ // ACCUMULATE ARGUMENTS - BEGIN
8320+ {
8321+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8322+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8323+ }
8324+ // ACCUMULATE ARGUMENTS - END
8325+ uint64_t return_to = 18446744073709551269LLU;
8326+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8327+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8328+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8329+ heap.data[0].elem1 = heap.data[0].elem0;
8330+ heap.data[0].elem0 = restore;
8331+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8332+ break;
8333+ }
8334+ case 18446744073709551269LLU: // 999999994j'''''''''''''''
8335+ {
8336+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7
8337+ state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
8338+ break;
8339+ }
8340+ case 18446744073709551272LLU: // 999999994m'''''''''''''''
8341+ {
8342+
8343+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0;
8344+ state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
8345+ break;
8346+ }
8347+ case 18446744073709551271LLU: // 999999994l'''''''''''''''
8348+ {
8349+ // parameter-reference resdest___ res0______ goes out of scope
8350+ // parameter-reference function__ x_________ goes out of scope
8351+ state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
8352+ break;
8353+ }
8354+ case 18446744073709551274LLU: // 999999994o'''''''''''''''
8355+ {
8356+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551268LLU : 18446744073709551267LLU;
8357+ break;
8358+ }
8359+ case 18446744073709551268LLU: // 999999994i'''''''''''''''
8360+ {
8361+ {
8362+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8);
8363+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8364+ }
8365+
8366+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0;
8367+ // variable resdest___ res1______ goes out of scope
8368+ // emitted destructur for type resdest___
8369+ // ACCUMULATE ARGUMENTS - BEGIN
8370+ {
8371+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8372+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8373+ }
8374+ // ACCUMULATE ARGUMENTS - END
8375+ uint64_t return_to = 18446744073709551265LLU;
8376+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8377+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8378+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8379+ heap.data[0].elem1 = heap.data[0].elem0;
8380+ heap.data[0].elem0 = restore;
8381+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8382+ break;
8383+ }
8384+ case 18446744073709551265LLU: // 999999994f'''''''''''''''
8385+ {
8386+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 5
8387+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
8388+ break;
8389+ }
8390+ case 18446744073709551267LLU: // 999999994h'''''''''''''''
8391+ {
8392+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
8393+ break;
8394+ }
8395+ case 18446744073709551266LLU: // 999999994g'''''''''''''''
8396+ {
8397+ // variable list<resdest___> yres______ goes out of scope
8398+ // emitted destructur for type list<resdest___>
8399+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8400+ break;
8401+ }
8402+ case 18446744073709551263LLU: // 999999994d'''''''''''''''
8403+ {
8404+ if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/)
8405+ {
8406+ state.addr = 18446744073709551264LLU; // 999999994e'''''''''''''''
8407+ break;
8408+ }
8409+ // temporary list-element
8410+ {
8411+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8);
8412+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8413+ }
8414+ // ACCUMULATE ARGUMENTS - BEGIN
8415+ {
8416+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8417+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8418+ }
8419+ // ACCUMULATE ARGUMENTS - END
8420+ uint64_t return_to = 18446744073709551262LLU;
8421+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8422+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8423+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8424+ heap.data[0].elem1 = heap.data[0].elem0;
8425+ heap.data[0].elem0 = restore;
8426+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8427+ break;
8428+ }
8429+ case 18446744073709551262LLU: // 999999994c'''''''''''''''
8430+ {
8431+ // RELEASE temporary destructor-variable
8432+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8433+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8434+ break;
8435+ }
8436+ case 18446744073709551264LLU: // 999999994e'''''''''''''''
8437+ {
8438+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 4
8439+ {
8440+ uint64_t arg = 0;
8441+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8442+ }
8443+ {
8444+ uint64_t arg = /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU));
8445+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8446+ }
8447+ {
8448+ uint64_t arg = 0;
8449+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8450+ }
8451+ state.addr = 18446744073709551261LLU; // 999999994b'''''''''''''''
8452+ break;
8453+ }
8454+ case 18446744073709551261LLU: // 999999994b'''''''''''''''
8455+ {
8456+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8457+ {
8458+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8459+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8460+ {
8461+ state.addr = 18446744073709551260LLU; // 999999994a'''''''''''''''
8462+ break;
8463+ }
8464+ }
8465+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8466+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8467+ {
8468+ uint64_t arg = 0;
8469+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8470+ }
8471+ // ACCUMULATE ARGUMENTS - BEGIN
8472+ {
8473+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8474+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8475+ }
8476+ {
8477+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
8478+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8479+ }
8480+ // ACCUMULATE ARGUMENTS - END
8481+ uint64_t return_to = 18446744073709551256LLU;
8482+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
8483+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8484+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8485+ heap.data[0].elem1 = heap.data[0].elem0;
8486+ heap.data[0].elem0 = restore;
8487+ state.addr = 296309897384864500LLU; // ParDefCopy
8488+ break;
8489+ }
8490+ case 18446744073709551256LLU: // 999999994X'''''''''''''''
8491+ {
8492+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551259LLU : 18446744073709551258LLU;
8493+ break;
8494+ }
8495+ case 18446744073709551259LLU: // 999999994$'''''''''''''''
8496+ {
8497+ {
8498+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
8499+ exit(-1);
8500+ }
8501+ // emitted destructur for type pardef____
8502+ // ACCUMULATE ARGUMENTS - BEGIN
8503+ {
8504+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8505+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8506+ }
8507+ // ACCUMULATE ARGUMENTS - END
8508+ uint64_t return_to = 18446744073709551255LLU;
8509+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8510+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8511+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8512+ heap.data[0].elem1 = heap.data[0].elem0;
8513+ heap.data[0].elem0 = restore;
8514+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8515+ break;
8516+ }
8517+ case 18446744073709551255LLU: // 999999994W'''''''''''''''
8518+ {
8519+ // parameter pardef____ new_______ goes out of scope
8520+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
8521+ break;
8522+ }
8523+ case 18446744073709551258LLU: // 999999994Z'''''''''''''''
8524+ {
8525+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
8526+ break;
8527+ }
8528+ case 18446744073709551257LLU: // 999999994Y'''''''''''''''
8529+ {
8530+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
8531+ // parameter-reference pardef____ par1______ goes out of scope
8532+ // parameter-reference function__ y_________ goes out of scope
8533+ state.addr = 18446744073709551261LLU; // 999999994b'''''''''''''''
8534+ break;
8535+ }
8536+ case 18446744073709551260LLU: // 999999994a'''''''''''''''
8537+ {
8538+ list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
8539+ {
8540+ uint64_t arg = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 1LLU));
8541+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8542+ }
8543+ {
8544+ uint64_t arg = 0;
8545+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8546+ }
8547+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
8548+ break;
8549+ }
8550+ case 18446744073709551254LLU: // 999999994V'''''''''''''''
8551+ {
8552+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8553+ {
8554+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8555+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8556+ {
8557+ state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
8558+ break;
8559+ }
8560+ }
8561+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8562+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8563+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551252LLU : 18446744073709551251LLU;
8564+ break;
8565+ }
8566+ case 18446744073709551252LLU: // 999999994T'''''''''''''''
8567+ {
8568+ {
8569+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 11);
8570+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8571+ }
8572+ {
8573+ uint64_t arg = 0;
8574+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8575+ }
8576+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = 0;
8577+ // ACCUMULATE ARGUMENTS - BEGIN
8578+ {
8579+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
8580+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8581+ }
8582+ {
8583+ uint64_t arg = /*par0______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
8584+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8585+ }
8586+ {
8587+ uint64_t arg = /*par1______*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 6LLU);
8588+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8589+ }
8590+ // ACCUMULATE ARGUMENTS - END
8591+ uint64_t return_to = 18446744073709551249LLU;
8592+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
8593+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8594+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8595+ heap.data[0].elem1 = heap.data[0].elem0;
8596+ heap.data[0].elem0 = restore;
8597+ state.addr = 589059743276730432LLU; // equpardef_
8598+ break;
8599+ }
8600+ case 18446744073709551249LLU: // 999999994Q'''''''''''''''
8601+ {
8602+
8603+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);
8604+ // variable u64 EQUAL_____ goes out of scope
8605+ // emitted destructur for type u64
8606+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 8
8607+ // variable pardef____ par1______ goes out of scope
8608+ // emitted destructur for type pardef____
8609+ // ACCUMULATE ARGUMENTS - BEGIN
8610+ {
8611+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8612+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8613+ }
8614+ // ACCUMULATE ARGUMENTS - END
8615+ uint64_t return_to = 18446744073709551248LLU;
8616+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8617+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8618+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8619+ heap.data[0].elem1 = heap.data[0].elem0;
8620+ heap.data[0].elem0 = restore;
8621+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8622+ break;
8623+ }
8624+ case 18446744073709551248LLU: // 999999994P'''''''''''''''
8625+ {
8626+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7
8627+ state.addr = 18446744073709551250LLU; // 999999994R'''''''''''''''
8628+ break;
8629+ }
8630+ case 18446744073709551251LLU: // 999999994S'''''''''''''''
8631+ {
8632+
8633+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0;
8634+ state.addr = 18446744073709551250LLU; // 999999994R'''''''''''''''
8635+ break;
8636+ }
8637+ case 18446744073709551250LLU: // 999999994R'''''''''''''''
8638+ {
8639+ // parameter-reference pardef____ par0______ goes out of scope
8640+ // parameter-reference function__ x_________ goes out of scope
8641+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
8642+ break;
8643+ }
8644+ case 18446744073709551253LLU: // 999999994U'''''''''''''''
8645+ {
8646+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551247LLU : 18446744073709551246LLU;
8647+ break;
8648+ }
8649+ case 18446744073709551247LLU: // 999999994O'''''''''''''''
8650+ {
8651+ {
8652+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 11);
8653+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8654+ }
8655+
8656+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0;
8657+ // variable pardef____ par1______ goes out of scope
8658+ // emitted destructur for type pardef____
8659+ // ACCUMULATE ARGUMENTS - BEGIN
8660+ {
8661+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8662+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8663+ }
8664+ // ACCUMULATE ARGUMENTS - END
8665+ uint64_t return_to = 18446744073709551244LLU;
8666+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8667+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8668+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8669+ heap.data[0].elem1 = heap.data[0].elem0;
8670+ heap.data[0].elem0 = restore;
8671+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8672+ break;
8673+ }
8674+ case 18446744073709551244LLU: // 999999994L'''''''''''''''
8675+ {
8676+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 5
8677+ state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
8678+ break;
8679+ }
8680+ case 18446744073709551246LLU: // 999999994N'''''''''''''''
8681+ {
8682+ state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
8683+ break;
8684+ }
8685+ case 18446744073709551245LLU: // 999999994M'''''''''''''''
8686+ {
8687+ // variable list<pardef____> ypars_____ goes out of scope
8688+ // emitted destructur for type list<pardef____>
8689+ state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
8690+ break;
8691+ }
8692+ case 18446744073709551242LLU: // 999999994J'''''''''''''''
8693+ {
8694+ if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/)
8695+ {
8696+ state.addr = 18446744073709551243LLU; // 999999994K'''''''''''''''
8697+ break;
8698+ }
8699+ // temporary list-element
8700+ {
8701+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 11);
8702+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8703+ }
8704+ // ACCUMULATE ARGUMENTS - BEGIN
8705+ {
8706+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8707+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8708+ }
8709+ // ACCUMULATE ARGUMENTS - END
8710+ uint64_t return_to = 18446744073709551241LLU;
8711+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8712+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8713+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8714+ heap.data[0].elem1 = heap.data[0].elem0;
8715+ heap.data[0].elem0 = restore;
8716+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
8717+ break;
8718+ }
8719+ case 18446744073709551241LLU: // 999999994I'''''''''''''''
8720+ {
8721+ // RELEASE temporary destructor-variable
8722+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8723+ state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
8724+ break;
8725+ }
8726+ case 18446744073709551243LLU: // 999999994K'''''''''''''''
8727+ {
8728+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 4
8729+ {
8730+ uint64_t arg = 0;
8731+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8732+ }
8733+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 2LLU));
8734+
8735+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
8736+ // variable u64 EQUAL_____ goes out of scope
8737+ // emitted destructur for type u64
8738+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 4
8739+ {
8740+ uint64_t arg = 0;
8741+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8742+ }
8743+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 3LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 3LLU));
8744+
8745+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
8746+ // variable u64 EQUAL_____ goes out of scope
8747+ // emitted destructur for type u64
8748+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 4
8749+ {
8750+ uint64_t arg = 0;
8751+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8752+ }
8753+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 4LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 4LLU));
8754+
8755+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
8756+ // variable u64 EQUAL_____ goes out of scope
8757+ // emitted destructur for type u64
8758+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 4
8759+ {
8760+ uint64_t arg = 0;
8761+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8762+ }
8763+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 5LLU)) == /*y_________*/*access_he

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

Show on old repository browser